* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*   http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*/

  private FsIndexDescription[] indexes;

  private TypeSystemDescription typeSystem;

  /**

   * Constructor for XmiCasDeserializerTest.

   *

   * @param arg0

   */

  public XmiCasDeserializerTest(String arg0) throws IOException {

    super(arg0);

  }

  protected void setUp() throws Exception {

    File typeSystemFile = JUnitExtension.getFile("ExampleCas/testTypeSystem.xml");

    File indexesFile = JUnitExtension.getFile("ExampleCas/testIndexes.xml");

    typeSystem = UIMAFramework.getXMLParser().parseTypeSystemDescription(

            new XMLInputSource(typeSystemFile));

    indexes = UIMAFramework.getXMLParser().parseFsIndexCollection(new XMLInputSource(indexesFile))

            .getFsIndexes();

  }

  public void testDeserializeAndReserialize() throws Exception {

    try {

      File tsWithNoMultiRefs = JUnitExtension.getFile("ExampleCas/testTypeSystem.xml");

      doTestDeserializeAndReserialize(tsWithNoMultiRefs,false);

      File tsWithMultiRefs = JUnitExtension.getFile("ExampleCas/testTypeSystem_withMultiRefs.xml");

      doTestDeserializeAndReserialize(tsWithMultiRefs,false);

      //also test with JCas initialized

      doTestDeserializeAndReserialize(tsWithNoMultiRefs,true);

      doTestDeserializeAndReserialize(tsWithMultiRefs,true);

    } catch (Exception e) {

      JUnitExtension.handleException(e);

    }

  }

  private void doTestDeserializeAndReserialize(File typeSystemDescriptorFile, boolean useJCas) throws Exception {

    // deserialize a complex CAS from XCAS

    TypeSystemDescription typeSystemDescription = UIMAFramework.getXMLParser().parseTypeSystemDescription(

            new XMLInputSource(typeSystemDescriptorFile));

    CAS cas = CasCreationUtils.createCas(typeSystemDescription, new TypePriorities_impl(), indexes);

    if (useJCas) {

      cas.getJCas();

    }

    InputStream serCasStream = new FileInputStream(JUnitExtension.getFile("ExampleCas/cas.xml"));

    XCASDeserializer deser = new XCASDeserializer(cas.getTypeSystem());

    ContentHandler deserHandler = deser.getXCASHandler(cas);

    SAXParserFactory fact = SAXParserFactory.newInstance();

    SAXParser parser = fact.newSAXParser();

    XMLReader xmlReader = parser.getXMLReader();

    xmlReader.setContentHandler(deserHandler);

    xmlReader.parse(new InputSource(serCasStream));

    serCasStream.close();

    // reserialize as XMI

    String xml = serialize(cas, null);

   

    // deserialize into another CAS

    CAS cas2 = CasCreationUtils.createCas(typeSystemDescription, new TypePriorities_impl(), indexes);

    if (useJCas) {

      cas2.getJCas();

    }

    XmiCasDeserializer deser2 = new XmiCasDeserializer(cas2.getTypeSystem());

    ContentHandler deserHandler2 = deser2.getXmiCasHandler(cas2);

    xmlReader.setContentHandler(deserHandler2);

    xmlReader.parse(new InputSource(new StringReader(xml)));

   

    // compare

    assertEquals(cas.getAnnotationIndex().size(), cas2.getAnnotationIndex().size());

    assertEquals(cas.getDocumentText(), cas2.getDocumentText());

    CasComparer.assertEquals(cas,cas2);

    // check that array refs are not null

    Type entityType = cas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.Entity");

    Feature classesFeat = entityType.getFeatureByBaseName("classes");

    Iterator<FeatureStructure> iter = cas2.getIndexRepository().getIndex("testEntityIndex").iterator();

    assertTrue(iter.hasNext());

    while (iter.hasNext()) {

      FeatureStructure fs = iter.next();

      StringArrayFS arrayFS = (StringArrayFS) fs.getFeatureValue(classesFeat);

      assertNotNull(arrayFS);

      for (int i = 0; i < arrayFS.size(); i++) {

        assertNotNull(arrayFS.get(i));

      }

    }

    Type annotArrayTestType = cas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.AnnotationArrayTest");

    Feature annotArrayFeat = annotArrayTestType.getFeatureByBaseName("arrayOfAnnotations");

    Iterator<AnnotationFS> iter2 = cas2.getAnnotationIndex(annotArrayTestType).iterator();

    assertTrue(iter2.hasNext());

    while (iter2.hasNext()) {

      FeatureStructure fs = iter2.next();

      ArrayFS arrayFS = (ArrayFS) fs.getFeatureValue(annotArrayFeat);

      assertNotNull(arrayFS);

      for (int i = 0; i < arrayFS.size(); i++) {

        assertNotNull(arrayFS.get(i));

      }

    }

   

    // test that lenient mode does not report errors

    CAS cas3 = CasCreationUtils.createCas(new TypeSystemDescription_impl(),

            new TypePriorities_impl(), new FsIndexDescription[0]);

    if (useJCas) {

      cas3.getJCas();

    }

    XmiCasDeserializer deser3 = new XmiCasDeserializer(cas3.getTypeSystem());

    ContentHandler deserHandler3 = deser3.getXmiCasHandler(cas3, true);

    xmlReader.setContentHandler(deserHandler3);

    xmlReader.parse(new InputSource(new StringReader(xml)));

  }

 

  public void testMultiThreadedSerialize() throws Exception {

    try {

      File tsWithNoMultiRefs = JUnitExtension.getFile("ExampleCas/testTypeSystem.xml");

      doTestMultiThreadedSerialize(tsWithNoMultiRefs);

      File tsWithMultiRefs = JUnitExtension.getFile("ExampleCas/testTypeSystem_withMultiRefs.xml");

      doTestMultiThreadedSerialize(tsWithMultiRefs);

    } catch (Exception e) {

      JUnitExtension.handleException(e);

    }

  }

  private static class DoSerialize implements Runnable{

    private CAS cas;

   

    DoSerialize(CAS aCas) {

      cas = aCas;

    }

   

    public void run() {

      try {

        serialize(cas, null);

//        serialize(cas, null);

//        serialize(cas, null);

      } catch (IOException e) {

     

        e.printStackTrace();

      } catch (SAXException e) {

       

        e.printStackTrace();

      }

    }

  }

 

  private static int MAX_THREADS = 16;

  // do as sequence 1, 2, 4, 8, 16 and measure elapsed time

  private static int [] threadsToUse = new int[] {1, 2, 4, 8, 16/*, 32, 64*/};

  private void doTestMultiThreadedSerialize(File typeSystemDescriptor) throws Exception {

    // deserialize a complex CAS from XCAS

    CAS cas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(), indexes);

    InputStream serCasStream = new FileInputStream(JUnitExtension.getFile("ExampleCas/cas.xml"));

    XCASDeserializer deser = new XCASDeserializer(cas.getTypeSystem());

    ContentHandler deserHandler = deser.getXCASHandler(cas);

    SAXParserFactory fact = SAXParserFactory.newInstance();

    SAXParser parser = fact.newSAXParser();

    XMLReader xmlReader = parser.getXMLReader();

    xmlReader.setContentHandler(deserHandler);

    xmlReader.parse(new InputSource(serCasStream));

    serCasStream.close();

    // make n copies of the cas, so they all share

    // the same type system

   

    final CAS [] cases = new CAS[MAX_THREADS];

   

    for (int i = 0; i < MAX_THREADS; i++) {

      cases[i] = CasCreationUtils.createCas(cas.getTypeSystem(), new TypePriorities_impl(),  indexes, null);

      CasCopier.copyCas(cas, cases[i], true);

    }

   

    // start n threads, serializing as XMI  

   

    for (int i = 0; i < threadsToUse.length; i++) {

      Thread [] threads = new Thread[MAX_THREADS];

      long startTime = System.currentTimeMillis();

      for (int ti = 0; ti < threadsToUse[i]; ti++) {

        threads[ti] = new Thread(new DoSerialize(cases[ti]));

       

        threads[ti].start();

      }

      for (int ti = 0; ti < threadsToUse[i]; ti++) {

        threads[ti].join();

        //System.out.print(" "+ ti);

      }

      System.out.println("\nNumber of threads serializing: " + threadsToUse[i] +

                         "  Normalized millisecs (should be close to the same): " + (System.currentTimeMillis() - startTime) / threadsToUse[i]);

    }

  }

  public void testDeltaCasIndexExistingFsInView() throws Exception {

    CAS cas1 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    CAS cas2 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    cas1.setDocumentText("This is a test document in the initial view");

    Type referentType = cas1.getTypeSystem().getType("org.apache.uima.testTypeSystem.Referent");

    FeatureStructure fs1 = cas1.createFS(referentType);

    cas1.getIndexRepository().addFS(fs1);

    //serialize complete

    XmiSerializationSharedData sharedData = new XmiSerializationSharedData();

    String xml = serialize(cas1, sharedData);

    System.out.println(xml);

    int maxOutgoingXmiId = sharedData.getMaxXmiId();

    //deserialize into cas2

    XmiSerializationSharedData sharedData2 = new XmiSerializationSharedData();

    this.deserialize(xml, cas2, sharedData2, true, -1);

    CasComparer.assertEquals(cas1, cas2);

    //create Marker, add/modify fs and serialize in delta xmi format.

    Marker marker = cas2.createMarker();

    //create View

    CAS view = cas2.createView("NewView");

    //add FS to index

    Type referentType2 = cas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.Referent");

    Iterator<FeatureStructure> fsIter = cas2.getIndexRepository().getAllIndexedFS(referentType2);

    while (fsIter.hasNext()) {

      FeatureStructure fs = fsIter.next();

      view.getIndexRepository().addFS(fs);

    }

    AnnotationFS cas2newAnnot = view.createAnnotation(cas2.getAnnotationType(), 6, 8);

    view.getIndexRepository().addFS(cas2newAnnot);

    // serialize cas2 in delta format

    String deltaxml1 = serialize(cas2, sharedData2, marker);

    System.out.println(deltaxml1);

    //deserialize delta xmi into cas1

    this.deserialize(deltaxml1, cas1, sharedData, true, maxOutgoingXmiId, AllowPreexistingFS.allow);

    //check that new View contains the FS

    CAS deserView = cas1.getView("NewView");

    Iterator<FeatureStructure> deserFsIter = deserView.getIndexRepository().getAllIndexedFS(referentType);

    assertTrue(deserFsIter.hasNext());

  }

  // test - initial view, no Sofa,

  public void testDeltaCasIndexExistingFsInInitialView() throws Exception {

    CAS cas1 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    CAS cas2 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    // no sofa

//    cas1.setDocumentText("This is a test document in the initial view");

    Type referentType = cas1.getTypeSystem().getType("org.apache.uima.testTypeSystem.Referent");

    FeatureStructure fs1 = cas1.createFS(referentType);

    cas1.getIndexRepository().addFS(fs1);  // index in initial view

    //serialize complete

    XmiSerializationSharedData sharedData = new XmiSerializationSharedData();

    String xml = serialize(cas1, sharedData);

    System.out.println(xml);

    int maxOutgoingXmiId = sharedData.getMaxXmiId();

    //deserialize into cas2

    XmiSerializationSharedData sharedData2 = new XmiSerializationSharedData();

    this.deserialize(xml, cas2, sharedData2, true, -1);

    CasComparer.assertEquals(cas1, cas2);

    //create Marker, add/modify fs and serialize in delta xmi format.

    Marker marker = cas2.createMarker();

    //create View

    CAS view = cas2.createView("NewView");

    //add FS to index

    Type referentType2 = cas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.Referent");

    Iterator<FeatureStructure> fsIter = cas2.getIndexRepository().getAllIndexedFS(referentType2);

    while (fsIter.hasNext()) {

      FeatureStructure fs = fsIter.next();

      view.getIndexRepository().addFS(fs);

    }

    AnnotationFS cas2newAnnot = view.createAnnotation(cas2.getAnnotationType(), 6, 8);

    view.getIndexRepository().addFS(cas2newAnnot);

    // add fs to initial view index repo.

   

    fs1 = cas2.createFS(referentType);

    cas2.getIndexRepository().addFS(fs1);

   

    // serialize cas2 in delta format

    String deltaxml1 = serialize(cas2, sharedData2, marker);

    System.out.println(deltaxml1);

    //deserialize delta xmi into cas1

    this.deserialize(deltaxml1, cas1, sharedData, true, maxOutgoingXmiId, AllowPreexistingFS.allow);

    //check that new View contains the FS

    CAS deserView = cas1.getView("NewView");

    Iterator<FeatureStructure> deserFsIter = deserView.getIndexRepository().getAllIndexedFS(referentType);

    assertTrue(deserFsIter.hasNext());

  }

 

  public void testDeltaCasIndexExistingFsInNewView() throws Exception {

    CAS cas1 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    CAS cas2 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    cas1.setDocumentText("This is a test document in the initial view");

    Type referentType = cas1.getTypeSystem().getType("org.apache.uima.testTypeSystem.Referent");

    FeatureStructure fs1 = cas1.createFS(referentType);

    cas1.getIndexRepository().addFS(fs1);

    //serialize complete

    XmiSerializationSharedData sharedData = new XmiSerializationSharedData();

    String xml = serialize(cas1, sharedData);

    System.out.println(xml);

    int maxOutgoingXmiId = sharedData.getMaxXmiId();

    //deserialize into cas2

    XmiSerializationSharedData sharedData2 = new XmiSerializationSharedData();

    this.deserialize(xml, cas2, sharedData2, true, -1);

    CasComparer.assertEquals(cas1, cas2);

    //create Marker, add/modify fs and serialize in delta xmi format.

    Marker marker = cas2.createMarker();

    //create View

    CAS view = cas2.createView("NewView");

    //add FS to index

    Type referentType2 = cas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.Referent");

    Iterator<FeatureStructure> fsIter = cas2.getIndexRepository().getAllIndexedFS(referentType2);

    while (fsIter.hasNext()) {

      FeatureStructure fs = fsIter.next();

      view.getIndexRepository().addFS(fs);

    }

    AnnotationFS cas2newAnnot = view.createAnnotation(cas2.getAnnotationType(), 6, 8);

    view.getIndexRepository().addFS(cas2newAnnot);

    // serialize cas2 in delta format

    String deltaxml1 = serialize(cas2, sharedData2, marker);

    System.out.println(deltaxml1);

    //deserialize delta xmi into cas1

    this.deserialize(deltaxml1, cas1, sharedData, true, maxOutgoingXmiId, AllowPreexistingFS.allow);

    //check that new View contains the FS

    CAS deserView = cas1.getView("NewView");

    Iterator<FeatureStructure> deserFsIter = deserView.getIndexRepository().getAllIndexedFS(referentType);

    assertTrue(deserFsIter.hasNext());

  }

  public void testMultipleSofas() throws Exception {

    try {

      CAS cas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

              new FsIndexDescription[0]);

      // set document text for the initial view

      cas.setDocumentText("This is a test");

      // create a new view and set its document text

      CAS cas2 = cas.createView("OtherSofa");

      cas2.setDocumentText("This is only a test");

      // create an annotation and add to index of both views

      AnnotationFS anAnnot = cas.createAnnotation(cas.getAnnotationType(), 0, 5);

      cas.getIndexRepository().addFS(anAnnot);

      cas2.getIndexRepository().addFS(anAnnot);

      FSIndex tIndex = cas.getAnnotationIndex();

      FSIndex t2Index = cas2.getAnnotationIndex();

      assertTrue(tIndex.size() == 2); // document annot and this one

      assertTrue(t2Index.size() == 2); // ditto

      // serialize

      StringWriter sw = new StringWriter();

      XMLSerializer xmlSer = new XMLSerializer(sw, false);

      XmiCasSerializer xmiSer = new XmiCasSerializer(cas.getTypeSystem());

      xmiSer.serialize(cas, xmlSer.getContentHandler());

      String xml = sw.getBuffer().toString();

      // deserialize into another CAS (repeat twice to check it still works after reset)

      CAS newCas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

              new FsIndexDescription[0]);

      for (int i = 0; i < 2; i++) {

        XmiCasDeserializer newDeser = new XmiCasDeserializer(newCas.getTypeSystem());

        ContentHandler newDeserHandler = newDeser.getXmiCasHandler(newCas);

        SAXParserFactory fact = SAXParserFactory.newInstance();

        SAXParser parser = fact.newSAXParser();

        XMLReader xmlReader = parser.getXMLReader();

        xmlReader.setContentHandler(newDeserHandler);

        xmlReader.parse(new InputSource(new StringReader(xml)));

        // check sofas

        assertEquals("This is a test", newCas.getDocumentText());

        CAS newCas2 = newCas.getView("OtherSofa");

        assertEquals("This is only a test", newCas2.getDocumentText());

        // check that annotation is still indexed in both views

        assertTrue(tIndex.size() == 2); // document annot and this one

        assertTrue(t2Index.size() == 2); // ditto

        newCas.reset();

      }

    } catch (Exception e) {

      JUnitExtension.handleException(e);

    }

  }

  public void testTypeSystemFiltering() throws Exception {

    try {

      // deserialize a complex CAS from XCAS

      CAS cas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(), indexes);

      InputStream serCasStream = new FileInputStream(JUnitExtension.getFile("ExampleCas/cas.xml"));

      XCASDeserializer deser = new XCASDeserializer(cas.getTypeSystem());

      ContentHandler deserHandler = deser.getXCASHandler(cas);

      SAXParserFactory fact = SAXParserFactory.newInstance();

      SAXParser parser = fact.newSAXParser();

      XMLReader xmlReader = parser.getXMLReader();

      xmlReader.setContentHandler(deserHandler);

      xmlReader.parse(new InputSource(serCasStream));

      serCasStream.close();

      // now read in a TypeSystem that's a subset of those types

      TypeSystemDescription partialTypeSystemDesc = UIMAFramework.getXMLParser()

              .parseTypeSystemDescription(

                      new XMLInputSource(JUnitExtension

                              .getFile("ExampleCas/partialTestTypeSystem.xml")));

      TypeSystem partialTypeSystem = CasCreationUtils.createCas(partialTypeSystemDesc, null, null)

              .getTypeSystem();

      // reserialize as XMI, filtering out anything that doesn't fit in the

      // partialTypeSystem

      StringWriter sw = new StringWriter();

      XMLSerializer xmlSer = new XMLSerializer(sw, false);

      XmiCasSerializer xmiSer = new XmiCasSerializer(partialTypeSystem);

      xmiSer.serialize(cas, xmlSer.getContentHandler());

      String xml = sw.getBuffer().toString();

      // System.out.println(xml);

      // deserialize into another CAS (which has the whole type system)

      CAS cas2 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(), indexes);

      XmiCasDeserializer deser2 = new XmiCasDeserializer(cas2.getTypeSystem());

      ContentHandler deserHandler2 = deser2.getXmiCasHandler(cas2);

      xmlReader.setContentHandler(deserHandler2);

      xmlReader.parse(new InputSource(new StringReader(xml)));

      // check that types have been filtered out

      Type orgType = cas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.Organization");

      assertNotNull(orgType);

      assertTrue(cas2.getAnnotationIndex(orgType).size() == 0);

      assertTrue(cas.getAnnotationIndex(orgType).size() > 0);

      // but that some types are still there

      Type personType = cas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.Person");

      FSIndex personIndex = cas2.getAnnotationIndex(personType);

      assertTrue(personIndex.size() > 0);

      // check that mentionType has been filtered out (set to null)

      FeatureStructure somePlace = personIndex.iterator().get();

      Feature mentionTypeFeat = personType.getFeatureByBaseName("mentionType");

      assertNotNull(mentionTypeFeat);

      assertNull(somePlace.getStringValue(mentionTypeFeat));

    } catch (Exception e) {

      JUnitExtension.handleException(e);

    }

  }

  public void testNoInitialSofa() throws Exception {

    CAS cas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            new FsIndexDescription[0]);

    // create non-annotation type so as not to create the _InitialView Sofa

    IntArrayFS intArrayFS = cas.createIntArrayFS(5);

    intArrayFS.set(0, 1);

    intArrayFS.set(1, 2);

    intArrayFS.set(2, 3);

    intArrayFS.set(3, 4);

    intArrayFS.set(4, 5);

    cas.getIndexRepository().addFS(intArrayFS);

    // serialize the CAS

    StringWriter sw = new StringWriter();

    XMLSerializer xmlSer = new XMLSerializer(sw, false);

    XmiCasSerializer xmiSer = new XmiCasSerializer(cas.getTypeSystem());

    xmiSer.serialize(cas, xmlSer.getContentHandler());

    String xml = sw.getBuffer().toString();

    // deserialize into another CAS

    CAS cas2 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            new FsIndexDescription[0]);

    XmiCasDeserializer deser2 = new XmiCasDeserializer(cas2.getTypeSystem());

    ContentHandler deserHandler2 = deser2.getXmiCasHandler(cas2);

    SAXParserFactory fact = SAXParserFactory.newInstance();

    SAXParser parser = fact.newSAXParser();

    XMLReader xmlReader = parser.getXMLReader();

    xmlReader.setContentHandler(deserHandler2);

    xmlReader.parse(new InputSource(new StringReader(xml)));

    //test that index is correctly populated

    Type intArrayType = cas2.getTypeSystem().getType(CAS.TYPE_NAME_INTEGER_ARRAY);

    Iterator<FeatureStructure> iter = cas2.getIndexRepository().getAllIndexedFS(intArrayType);

    assertTrue(iter.hasNext());

    IntArrayFS intArrayFS2 = (IntArrayFS)iter.next();

    assertFalse(iter.hasNext());

    assertEquals(5, intArrayFS2.size());

    assertEquals(1, intArrayFS2.get(0));

    assertEquals(2, intArrayFS2.get(1));

    assertEquals(3, intArrayFS2.get(2));

    assertEquals(4, intArrayFS2.get(3));

    assertEquals(5, intArrayFS2.get(4));

    // test that serializing the new CAS produces the same XML

    sw = new StringWriter();

    xmlSer = new XMLSerializer(sw, false);

    xmiSer = new XmiCasSerializer(cas2.getTypeSystem());

    xmiSer.serialize(cas2, xmlSer.getContentHandler());

    String xml2 = sw.getBuffer().toString();   

    assertTrue(xml2.equals(xml));

  }

  public void testv1FormatXcas() throws Exception {

    CAS cas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            new FsIndexDescription[0]);

    CAS v1cas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            new FsIndexDescription[0]);

    // get a complex CAS

    InputStream serCasStream = new FileInputStream(JUnitExtension.getFile("ExampleCas/cas.xml"));

    XCASDeserializer deser = new XCASDeserializer(cas.getTypeSystem());

    ContentHandler deserHandler = deser.getXCASHandler(cas);

    SAXParserFactory fact = SAXParserFactory.newInstance();

    SAXParser parser = fact.newSAXParser();

    XMLReader xmlReader = parser.getXMLReader();

    xmlReader.setContentHandler(deserHandler);

    xmlReader.parse(new InputSource(serCasStream));

    serCasStream.close();

    // test it

    assertTrue(CAS.NAME_DEFAULT_SOFA.equals(cas.getSofa().getSofaID()));

    // get a v1 XMI version of the same CAS

    serCasStream = new FileInputStream(JUnitExtension.getFile("ExampleCas/v1xmiCas.xml"));

    XmiCasDeserializer deser2 = new XmiCasDeserializer(v1cas.getTypeSystem());

    ContentHandler deserHandler2 = deser2.getXmiCasHandler(v1cas);

    xmlReader.setContentHandler(deserHandler2);

    xmlReader.parse(new InputSource(serCasStream));

    serCasStream.close();

    // compare

    assertEquals(cas.getAnnotationIndex().size(), v1cas.getAnnotationIndex().size());

    assertTrue(CAS.NAME_DEFAULT_SOFA.equals(v1cas.getSofa().getSofaID()));

    // now a v1 XMI version of a multiple Sofa CAS

    v1cas.reset();

    serCasStream = new FileInputStream(JUnitExtension.getFile("ExampleCas/xmiMsCasV1.xml"));

    deser2 = new XmiCasDeserializer(v1cas.getTypeSystem());

    deserHandler2 = deser2.getXmiCasHandler(v1cas);

    xmlReader.setContentHandler(deserHandler2);

    xmlReader.parse(new InputSource(serCasStream));

    serCasStream.close();

    // test it

    CAS engView = v1cas.getView("EnglishDocument");

    assertTrue(engView.getDocumentText().equals("this beer is good"));

    assertTrue(engView.getAnnotationIndex().size() == 5); // 4 annots plus documentAnnotation

    CAS gerView = v1cas.getView("GermanDocument");

    assertTrue(gerView.getDocumentText().equals("das bier ist gut"));

    assertTrue(gerView.getAnnotationIndex().size() == 5); // 4 annots plus documentAnnotation

    assertTrue(CAS.NAME_DEFAULT_SOFA.equals(v1cas.getSofa().getSofaID()));

    assertTrue(v1cas.getDocumentText().equals("some text for the default text sofa."));

    // reserialize as XMI

    StringWriter sw = new StringWriter();

    XMLSerializer xmlSer = new XMLSerializer(sw, false);

    XmiCasSerializer xmiSer = new XmiCasSerializer(v1cas.getTypeSystem());

    xmiSer.serialize(v1cas, xmlSer.getContentHandler());

    String xml = sw.getBuffer().toString();

    cas.reset();

    // deserialize into another CAS

    deser2 = new XmiCasDeserializer(cas.getTypeSystem());

    deserHandler2 = deser2.getXmiCasHandler(cas);

    xmlReader.setContentHandler(deserHandler2);

    xmlReader.parse(new InputSource(new StringReader(xml)));

    // test it

    engView = cas.getView("EnglishDocument");

    assertTrue(engView.getDocumentText().equals("this beer is good"));

    assertTrue(engView.getAnnotationIndex().size() == 5); // 4 annots plus documentAnnotation

    gerView = cas.getView("GermanDocument");

    assertTrue(gerView.getDocumentText().equals("das bier ist gut"));

    assertTrue(gerView.getAnnotationIndex().size() == 5); // 4 annots plus documentAnnotation

    assertTrue(CAS.NAME_DEFAULT_SOFA.equals(v1cas.getSofa().getSofaID()));

    assertTrue(v1cas.getDocumentText().equals("some text for the default text sofa."));

  }

 

  public void testDuplicateNsPrefixes() throws Exception {

    TypeSystemDescription ts = new TypeSystemDescription_impl();

    ts.addType("org.bar.foo.Foo", "", "uima.tcas.Annotation");

    ts.addType("org.baz.foo.Foo", "", "uima.tcas.Annotation");

    CAS cas = CasCreationUtils.createCas(ts, null, null);

    cas.setDocumentText("Foo");

    Type t1 = cas.getTypeSystem().getType("org.bar.foo.Foo");

    Type t2 = cas.getTypeSystem().getType("org.baz.foo.Foo");

    AnnotationFS a1 = cas.createAnnotation(t1,0,3);

    cas.addFsToIndexes(a1);

    AnnotationFS a2 = cas.createAnnotation(t2,0,3);

    cas.addFsToIndexes(a2);

    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    XmiCasSerializer.serialize(cas, baos);

    baos.close();

    byte[] bytes = baos.toByteArray();

   

    CAS cas2 = CasCreationUtils.createCas(ts, null, null);

    ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

    XmiCasDeserializer.deserialize(bais, cas2);

    bais.close();

   

    CasComparer.assertEquals(cas, cas2);

  }

  public void testMerging() throws Exception {

    testMerging(false);

  }

  public void testDeltaCasMerging() throws Exception {

    testMerging(true);

  }

 

  // Test merging with or without using delta CASes

  private void testMerging(boolean useDeltas) throws Exception {

    // deserialize a complex CAS from XCAS

    CAS cas = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(), indexes);

    InputStream serCasStream = new FileInputStream(JUnitExtension.getFile("ExampleCas/cas.xml"));

    XCASDeserializer.deserialize(serCasStream, cas);

    serCasStream.close();

    int numAnnotations = cas.getAnnotationIndex().size(); //for comparison later

    String docText = cas.getDocumentText(); //for comparison later

    //add a new Sofa to test that multiple Sofas in original CAS work

    CAS preexistingView = cas.createView("preexistingView");

    String preexistingViewText = "John Smith blah blah blah";

    preexistingView.setDocumentText(preexistingViewText);

    createPersonAnnot(preexistingView, 0, 10);

   

    // do XMI serialization to a string, using XmiSerializationSharedData

    // to keep track of maximum ID generated

    XmiSerializationSharedData serSharedData = new XmiSerializationSharedData();

    String xmiStr = serialize(cas, serSharedData);

    int maxOutgoingXmiId = serSharedData.getMaxXmiId();

   

    // deserialize into two new CASes, each with its own instance of XmiSerializationSharedData

    // so we can get consistent IDs later when serializing back.

    CAS newCas1 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(), indexes);

    XmiSerializationSharedData deserSharedData1 = new XmiSerializationSharedData();

    deserialize(xmiStr, newCas1, deserSharedData1, false, -1);

   

    CAS newCas2 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(), indexes);

    XmiSerializationSharedData deserSharedData2 = new XmiSerializationSharedData();

    deserialize(xmiStr, newCas2, deserSharedData2, false, -1);

    Marker marker1 = null;

    Marker marker2 = null;

    if (useDeltas) {

      // create Marker before adding new FSs

      marker1 = newCas1.createMarker();

      marker2 = newCas2.createMarker();

    }

   

    //add new FS to each new CAS

    createPersonAnnot(newCas1, 0, 10);

    createPersonAnnot(newCas1, 20, 30);

    createPersonAnnot(newCas2, 40, 50);

    AnnotationFS person = createPersonAnnot(newCas2, 60, 70);

   

    //add an Owner relation that points to an organization in the original CAS,

    //to test links across merge boundary

    Type orgType = newCas2.getTypeSystem().getType(

            "org.apache.uima.testTypeSystem.Organization");

    AnnotationFS org = (AnnotationFS)newCas2.getAnnotationIndex(orgType).iterator().next();

    Type ownerType = newCas2.getTypeSystem().getType(

            "org.apache.uima.testTypeSystem.Owner");

    Feature argsFeat = ownerType.getFeatureByBaseName("relationArgs");

    Feature componentIdFeat = ownerType.getFeatureByBaseName("componentId");

    Type relArgsType = newCas2.getTypeSystem().getType(

            "org.apache.uima.testTypeSystem.BinaryRelationArgs");

    Feature domainFeat = relArgsType.getFeatureByBaseName("domainValue");

    Feature rangeFeat = relArgsType.getFeatureByBaseName("rangeValue");

    AnnotationFS ownerAnnot = newCas2.createAnnotation(ownerType, 0, 70);

    FeatureStructure relArgs = newCas2.createFS(relArgsType);

    relArgs.setFeatureValue(domainFeat, person);

    relArgs.setFeatureValue(rangeFeat, org);

    ownerAnnot.setFeatureValue(argsFeat, relArgs);

    ownerAnnot.setStringValue(componentIdFeat, "XCasDeserializerTest");

    newCas2.addFsToIndexes(ownerAnnot);

    int orgBegin = org.getBegin();

    int orgEnd = org.getEnd();

   

    //add Sofas

    CAS newView1 = newCas1.createView("newSofa1");

    final String sofaText1 = "This is a new Sofa, created in CAS 1.";

    newView1.setDocumentText(sofaText1);

    final String annotText = "Sofa";

    int annotStart1 = sofaText1.indexOf(annotText);

    AnnotationFS annot1 = newView1.createAnnotation(orgType, annotStart1, annotStart1 + annotText.length());

    newView1.addFsToIndexes(annot1);

    CAS newView2 = newCas2.createView("newSofa2");

    final String sofaText2 = "This is another new Sofa, created in CAS 2.";

    newView2.setDocumentText(sofaText2);

    int annotStart2 = sofaText2.indexOf(annotText);

    AnnotationFS annot2 = newView2.createAnnotation(orgType, annotStart2, annotStart2 + annotText.length());

    newView2.addFsToIndexes(annot2);

    // Add an FS with an array of existing annotations in another view

    int nToks = 3;

    ArrayFS array = newView2.createArrayFS(nToks);

    Type thingType = newCas2.getTypeSystem().getType("org.apache.uima.testTypeSystem.Thing");

    FSIterator thingIter = newCas2.getAnnotationIndex(thingType).iterator();

    for (int i = 0; i < nToks; ++i)

      array.set(i, (FeatureStructure)thingIter.next()); 

    Type annotArrayTestType = newView2.getTypeSystem().getType("org.apache.uima.testTypeSystem.AnnotationArrayTest");

    Feature annotArrayFeat = annotArrayTestType.getFeatureByBaseName("arrayOfAnnotations");

    AnnotationFS fsArrayTestAnno = newView2.createAnnotation(annotArrayTestType, 13, 27);

    fsArrayTestAnno.setFeatureValue(annotArrayFeat,array);

    newView2.addFsToIndexes(fsArrayTestAnno);

   

    // re-serialize each new CAS back to XMI, keeping consistent ids

    String newSerCas1 = serialize(newCas1, deserSharedData1, marker1);

    String newSerCas2 = serialize(newCas2, deserSharedData2, marker2);

   

    // merge the two XMI CASes back into the original CAS

    // the shared data will be reset and recreated if not using deltaCas

    if (useDeltas) {

      deserialize(newSerCas1, cas, serSharedData, false, maxOutgoingXmiId);

    } else {

      deserialize(newSerCas1, cas, serSharedData, false, -1);

    }

    assertEquals(numAnnotations + 2, cas.getAnnotationIndex().size());

    deserialize(newSerCas2, cas, serSharedData, false, maxOutgoingXmiId);

    assertEquals(numAnnotations + 5, cas.getAnnotationIndex().size());

    assertEquals(docText, cas.getDocumentText());

    // Serialize/deserialize again in case merge created duplicate ids

    String newSerCasMerged = serialize(cas, serSharedData);

    deserialize(newSerCasMerged, cas, serSharedData, false, -1);

   

    //check covered text of annotations

    FSIterator iter = cas.getAnnotationIndex().iterator();

    while (iter.hasNext()) {

      AnnotationFS annot = (AnnotationFS)iter.next();

      assertEquals(cas.getDocumentText().substring(

              annot.getBegin(), annot.getEnd()), annot.getCoveredText());

    }

    //check Owner annotation we created to test link across merge boundary

    iter = cas.getAnnotationIndex(ownerType).iterator();

    while (iter.hasNext()) {

      AnnotationFS

      annot = (AnnotationFS)iter.next();

      String componentId = annot.getStringValue(componentIdFeat);

      if ("XCasDeserializerTest".equals(componentId)) {

        FeatureStructure targetRelArgs = annot.getFeatureValue(argsFeat);

        AnnotationFS targetDomain = (AnnotationFS)targetRelArgs.getFeatureValue(domainFeat);

        assertEquals(60, targetDomain.getBegin());

        assertEquals(70, targetDomain.getEnd());

        AnnotationFS targetRange = (AnnotationFS)targetRelArgs.getFeatureValue(rangeFeat);

        assertEquals(orgBegin, targetRange.getBegin());

        assertEquals(orgEnd, targetRange.getEnd());

      }    

    }

    //check Sofas

    CAS targetView1 = cas.getView("newSofa1");

    assertEquals(sofaText1, targetView1.getDocumentText());

    CAS targetView2 = cas.getView("newSofa2");

    assertEquals(sofaText2, targetView2.getDocumentText());

    AnnotationFS targetAnnot1 = (AnnotationFS)

      targetView1.getAnnotationIndex(orgType).iterator().get();

    assertEquals(annotText, targetAnnot1.getCoveredText());

    AnnotationFS targetAnnot2 = (AnnotationFS)

    targetView2.getAnnotationIndex(orgType).iterator().get();

    assertEquals(annotText, targetAnnot2.getCoveredText());

    assertTrue(targetView1.getSofa().getSofaRef() !=

            targetView2.getSofa().getSofaRef());

   

    CAS checkPreexistingView = cas.getView("preexistingView");

    assertEquals(preexistingViewText, checkPreexistingView.getDocumentText());

    Type personType = cas.getTypeSystem().getType("org.apache.uima.testTypeSystem.Person");   

    AnnotationFS targetAnnot3 = (AnnotationFS)

            checkPreexistingView.getAnnotationIndex(personType).iterator().get();

    assertEquals("John Smith", targetAnnot3.getCoveredText());

    // Check the FS with an array of pre-existing FSs

    iter = targetView2.getAnnotationIndex(annotArrayTestType).iterator();

    componentIdFeat = thingType.getFeatureByBaseName("componentId");

    while (iter.hasNext()) {

      AnnotationFS annot = (AnnotationFS)iter.next();

      ArrayFS fsArray = (ArrayFS)annot.getFeatureValue(annotArrayFeat);

      assertTrue(fsArray.size() == 3);

      for (int i = 0; i < fsArray.size(); ++i) {

        AnnotationFS refAnno = (AnnotationFS)fsArray.get(i);

        assertEquals(thingType.getName(), refAnno.getType().getName());

        assertEquals("JResporator", refAnno.getStringValue(componentIdFeat));

        assertTrue(cas == refAnno.getView());

      }

    }

   

    //try an initial CAS that contains multiple Sofas

   

  }

 

  public void testDeltaCasIgnorePreexistingFS() throws Exception {

   try {

    CAS cas1 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    CAS cas2 = CasCreationUtils.createCas(typeSystem, new TypePriorities_impl(),

            indexes);

    cas1.setDocumentText("This is a test document in the initial view");

    AnnotationFS anAnnot1 = cas1.createAnnotation(cas1.getAnnotationType(), 0, 4);

    cas1.getIndexRepository().addFS(anAnnot1);

    AnnotationFS anAnnot2 = cas1.createAnnotation(cas1.getAnnotationType(), 5, 10);