@Test
  public void testRecoverWithOperationsBetweenPhase1AndPhase2() throws Exception {
    ParsedDocument doc1 =
        testParsedDocument(
            "1",
            "1",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_1,
            false);
    engine.create(new Engine.Create(null, newUid("1"), doc1));
    engine.flush(new Engine.Flush());
    ParsedDocument doc2 =
        testParsedDocument(
            "2",
            "2",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_2,
            false);
    engine.create(new Engine.Create(null, newUid("2"), doc2));

    engine.recover(
        new Engine.RecoveryHandler() {
          @Override
          public void phase1(SnapshotIndexCommit snapshot) throws EngineException {}

          @Override
          public void phase2(Translog.Snapshot snapshot) throws EngineException {
            assertThat(snapshot.hasNext(), equalTo(true));
            Translog.Create create = (Translog.Create) snapshot.next();
            assertThat(create.source().toBytesArray(), equalTo(B_2));
            assertThat(snapshot.hasNext(), equalTo(false));
          }

          @Override
          public void phase3(Translog.Snapshot snapshot) throws EngineException {
            MatcherAssert.assertThat(snapshot, TranslogSizeMatcher.translogSize(0));
          }
        });

    engine.flush(new Engine.Flush());
    engine.close();
  }
  @Test
  public void testVersioningNewCreate() {
    ParsedDocument doc =
        testParsedDocument(
            "1", "1", "test", null, -1, -1, testDocument(), Lucene.STANDARD_ANALYZER, B_1, false);
    Engine.Create create = new Engine.Create(null, newUid("1"), doc);
    engine.create(create);
    assertThat(create.version(), equalTo(1l));

    create = new Engine.Create(null, newUid("1"), doc).version(create.version()).origin(REPLICA);
    replicaEngine.create(create);
    assertThat(create.version(), equalTo(1l));
  }
  @Test
  public void testVersioningCreateExistsException() {
    ParsedDocument doc =
        testParsedDocument(
            "1", "1", "test", null, -1, -1, testDocument(), Lucene.STANDARD_ANALYZER, B_1, false);
    Engine.Create create = new Engine.Create(null, newUid("1"), doc);
    engine.create(create);
    assertThat(create.version(), equalTo(1l));

    create = new Engine.Create(null, newUid("1"), doc);
    try {
      engine.create(create);
      assert false;
    } catch (DocumentAlreadyExistsException e) {
      // all is well
    }
  }
  @Test
  public void testVersioningDeleteConflictWithFlush() {
    ParsedDocument doc =
        testParsedDocument(
            "1", "1", "test", null, -1, -1, testDocument(), Lucene.STANDARD_ANALYZER, B_1, false);
    Engine.Index index = new Engine.Index(null, newUid("1"), doc);
    engine.index(index);
    assertThat(index.version(), equalTo(1l));

    index = new Engine.Index(null, newUid("1"), doc);
    engine.index(index);
    assertThat(index.version(), equalTo(2l));

    engine.flush(new Engine.Flush());

    Engine.Delete delete = new Engine.Delete("test", "1", newUid("1")).version(1l);
    try {
      engine.delete(delete);
      assert false;
    } catch (VersionConflictEngineException e) {
      // all is well
    }

    // future versions should not work as well
    delete = new Engine.Delete("test", "1", newUid("1")).version(3l);
    try {
      engine.delete(delete);
      assert false;
    } catch (VersionConflictEngineException e) {
      // all is well
    }

    engine.flush(new Engine.Flush());

    // now actually delete
    delete = new Engine.Delete("test", "1", newUid("1")).version(2l);
    engine.delete(delete);
    assertThat(delete.version(), equalTo(3l));

    engine.flush(new Engine.Flush());

    // now check if we can index to a delete doc with version
    index = new Engine.Index(null, newUid("1"), doc).version(2l);
    try {
      engine.index(index);
      assert false;
    } catch (VersionConflictEngineException e) {
      // all is well
    }

    // we shouldn't be able to create as well
    Engine.Create create = new Engine.Create(null, newUid("1"), doc).version(2l);
    try {
      engine.create(create);
    } catch (VersionConflictEngineException e) {
      // all is well
    }
  }
  @Test
  public void testSimpleRecover() throws Exception {
    ParsedDocument doc =
        testParsedDocument(
            "1",
            "1",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_1,
            false);
    engine.create(new Engine.Create(null, newUid("1"), doc));
    engine.flush(new Engine.Flush());

    engine.recover(
        new Engine.RecoveryHandler() {
          @Override
          public void phase1(SnapshotIndexCommit snapshot) throws EngineException {
            try {
              engine.flush(new Engine.Flush());
              assertThat("flush is not allowed in phase 3", false, equalTo(true));
            } catch (FlushNotAllowedEngineException e) {
              // all is well
            }
          }

          @Override
          public void phase2(Translog.Snapshot snapshot) throws EngineException {
            MatcherAssert.assertThat(snapshot, TranslogSizeMatcher.translogSize(0));
            try {
              engine.flush(new Engine.Flush());
              assertThat("flush is not allowed in phase 3", false, equalTo(true));
            } catch (FlushNotAllowedEngineException e) {
              // all is well
            }
          }

          @Override
          public void phase3(Translog.Snapshot snapshot) throws EngineException {
            MatcherAssert.assertThat(snapshot, TranslogSizeMatcher.translogSize(0));
            try {
              // we can do this here since we are on the same thread
              engine.flush(new Engine.Flush());
              assertThat("flush is not allowed in phase 3", false, equalTo(true));
            } catch (FlushNotAllowedEngineException e) {
              // all is well
            }
          }
        });

    engine.flush(new Engine.Flush());
    engine.close();
  }
  public SimpleEngineBenchmark build() {
    for (int i = 0; i < searcherThreads.length; i++) {
      searcherThreads[i] = new Thread(new SearcherThread(), "Searcher[" + i + "]");
    }
    for (int i = 0; i < writerThreads.length; i++) {
      writerThreads[i] = new Thread(new WriterThread(), "Writer[" + i + "]");
    }

    latch = new CountDownLatch(searcherThreads.length + writerThreads.length);
    barrier1 = new CyclicBarrier(searcherThreads.length + writerThreads.length + 1);
    barrier2 = new CyclicBarrier(searcherThreads.length + writerThreads.length + 1);

    // warmup by indexing all content items
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    for (String contentItem : contentItems) {
      int id = idGenerator.incrementAndGet();
      String sId = Integer.toString(id);
      Document doc = doc().add(field("_id", sId)).add(field("content", contentItem)).build();
      if (create) {
        engine.create(
            new Engine.Create(doc, Lucene.STANDARD_ANALYZER, "type", sId, TRANSLOG_PAYLOAD));
      } else {
        engine.index(
            new Engine.Index(
                new Term("_id", sId),
                doc,
                Lucene.STANDARD_ANALYZER,
                "type",
                sId,
                TRANSLOG_PAYLOAD));
      }
    }
    engine.refresh(new Engine.Refresh(true));
    stopWatch.stop();
    System.out.println(
        "Warmup of [" + contentItems.length + "] content items, took " + stopWatch.totalTime());

    return this;
  }
  @Test
  public void testSimpleSnapshot() throws Exception {
    // create a document
    ParsedDocument doc1 =
        testParsedDocument(
            "1",
            "1",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_1,
            false);
    engine.create(new Engine.Create(null, newUid("1"), doc1));

    final ExecutorService executorService = Executors.newCachedThreadPool();

    engine.snapshot(
        new Engine.SnapshotHandler<Void>() {
          @Override
          public Void snapshot(
              final SnapshotIndexCommit snapshotIndexCommit1,
              final Translog.Snapshot translogSnapshot1) {
            MatcherAssert.assertThat(
                snapshotIndexCommit1, SnapshotIndexCommitExistsMatcher.snapshotIndexCommitExists());
            assertThat(translogSnapshot1.hasNext(), equalTo(true));
            Translog.Create create1 = (Translog.Create) translogSnapshot1.next();
            assertThat(create1.source().toBytesArray(), equalTo(B_1.toBytesArray()));
            assertThat(translogSnapshot1.hasNext(), equalTo(false));

            Future<Object> future =
                executorService.submit(
                    new Callable<Object>() {
                      @Override
                      public Object call() throws Exception {
                        engine.flush(new Engine.Flush());
                        ParsedDocument doc2 =
                            testParsedDocument(
                                "2",
                                "2",
                                "test",
                                null,
                                -1,
                                -1,
                                testDocumentWithTextField(),
                                Lucene.STANDARD_ANALYZER,
                                B_2,
                                false);
                        engine.create(new Engine.Create(null, newUid("2"), doc2));
                        engine.flush(new Engine.Flush());
                        ParsedDocument doc3 =
                            testParsedDocument(
                                "3",
                                "3",
                                "test",
                                null,
                                -1,
                                -1,
                                testDocumentWithTextField(),
                                Lucene.STANDARD_ANALYZER,
                                B_3,
                                false);
                        engine.create(new Engine.Create(null, newUid("3"), doc3));
                        return null;
                      }
                    });

            try {
              future.get();
            } catch (Exception e) {
              e.printStackTrace();
              assertThat(e.getMessage(), false, equalTo(true));
            }

            MatcherAssert.assertThat(
                snapshotIndexCommit1, SnapshotIndexCommitExistsMatcher.snapshotIndexCommitExists());

            engine.snapshot(
                new Engine.SnapshotHandler<Void>() {
                  @Override
                  public Void snapshot(
                      SnapshotIndexCommit snapshotIndexCommit2, Translog.Snapshot translogSnapshot2)
                      throws EngineException {
                    MatcherAssert.assertThat(
                        snapshotIndexCommit1,
                        SnapshotIndexCommitExistsMatcher.snapshotIndexCommitExists());
                    MatcherAssert.assertThat(
                        snapshotIndexCommit2,
                        SnapshotIndexCommitExistsMatcher.snapshotIndexCommitExists());
                    assertThat(
                        snapshotIndexCommit2.getSegmentsFileName(),
                        not(equalTo(snapshotIndexCommit1.getSegmentsFileName())));
                    assertThat(translogSnapshot2.hasNext(), equalTo(true));
                    Translog.Create create3 = (Translog.Create) translogSnapshot2.next();
                    assertThat(create3.source().toBytesArray(), equalTo(B_3.toBytesArray()));
                    assertThat(translogSnapshot2.hasNext(), equalTo(false));
                    return null;
                  }
                });
            return null;
          }
        });

    engine.close();
  }
  @Test
  public void testSearchResultRelease() throws Exception {
    Engine.Searcher searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(0));
    searchResult.release();

    // create a document
    ParsedDocument doc =
        testParsedDocument(
            "1",
            "1",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_1,
            false);
    engine.create(new Engine.Create(null, newUid("1"), doc));

    // its not there...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 0));
    searchResult.release();

    // refresh and it should be there
    engine.refresh(new Engine.Refresh(true));

    // now its there...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 1));
    // don't release the search result yet...

    // delete, refresh and do a new search, it should not be there
    engine.delete(new Engine.Delete("test", "1", newUid("1")));
    engine.refresh(new Engine.Refresh(true));
    Engine.Searcher updateSearchResult = engine.searcher();
    MatcherAssert.assertThat(
        updateSearchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(0));
    updateSearchResult.release();

    // the non release search result should not see the deleted yet...
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 1));
    searchResult.release();
  }
  @Test
  public void testSimpleOperations() throws Exception {
    Engine.Searcher searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(0));
    searchResult.release();

    // create a document
    Document document = testDocumentWithTextField();
    document.add(
        new Field(SourceFieldMapper.NAME, B_1.toBytes(), SourceFieldMapper.Defaults.FIELD_TYPE));
    ParsedDocument doc =
        testParsedDocument(
            "1", "1", "test", null, -1, -1, document, Lucene.STANDARD_ANALYZER, B_1, false);
    engine.create(new Engine.Create(null, newUid("1"), doc));

    // its not there...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 0));
    searchResult.release();

    // but, we can still get it (in realtime)
    Engine.GetResult getResult = engine.get(new Engine.Get(true, newUid("1")));
    assertThat(getResult.exists(), equalTo(true));
    assertThat(getResult.source().source.toBytesArray(), equalTo(B_1.toBytesArray()));
    assertThat(getResult.docIdAndVersion(), nullValue());

    // but, not there non realtime
    getResult = engine.get(new Engine.Get(false, newUid("1")));
    assertThat(getResult.exists(), equalTo(false));

    // refresh and it should be there
    engine.refresh(new Engine.Refresh(true));

    // now its there...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 1));
    searchResult.release();

    // also in non realtime
    getResult = engine.get(new Engine.Get(false, newUid("1")));
    assertThat(getResult.exists(), equalTo(true));
    assertThat(getResult.docIdAndVersion(), notNullValue());

    // now do an update
    document = testDocument();
    document.add(new TextField("value", "test1", Field.Store.YES));
    document.add(
        new Field(SourceFieldMapper.NAME, B_2.toBytes(), SourceFieldMapper.Defaults.FIELD_TYPE));
    doc =
        testParsedDocument(
            "1", "1", "test", null, -1, -1, document, Lucene.STANDARD_ANALYZER, B_2, false);
    engine.index(new Engine.Index(null, newUid("1"), doc));

    // its not updated yet...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 0));
    searchResult.release();

    // but, we can still get it (in realtime)
    getResult = engine.get(new Engine.Get(true, newUid("1")));
    assertThat(getResult.exists(), equalTo(true));
    assertThat(getResult.source().source.toBytesArray(), equalTo(B_2.toBytesArray()));
    assertThat(getResult.docIdAndVersion(), nullValue());

    // refresh and it should be updated
    engine.refresh(new Engine.Refresh(true));

    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 1));
    searchResult.release();

    // now delete
    engine.delete(new Engine.Delete("test", "1", newUid("1")));

    // its not deleted yet
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 1));
    searchResult.release();

    // but, get should not see it (in realtime)
    getResult = engine.get(new Engine.Get(true, newUid("1")));
    assertThat(getResult.exists(), equalTo(false));

    // refresh and it should be deleted
    engine.refresh(new Engine.Refresh(true));

    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 0));
    searchResult.release();

    // add it back
    document = testDocumentWithTextField();
    document.add(
        new Field(SourceFieldMapper.NAME, B_1.toBytes(), SourceFieldMapper.Defaults.FIELD_TYPE));
    doc =
        testParsedDocument(
            "1", "1", "test", null, -1, -1, document, Lucene.STANDARD_ANALYZER, B_1, false);
    engine.create(new Engine.Create(null, newUid("1"), doc));

    // its not there...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 0));
    searchResult.release();

    // refresh and it should be there
    engine.refresh(new Engine.Refresh(true));

    // now its there...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 0));
    searchResult.release();

    // now flush
    engine.flush(new Engine.Flush());

    // and, verify get (in real time)
    getResult = engine.get(new Engine.Get(true, newUid("1")));
    assertThat(getResult.exists(), equalTo(true));
    assertThat(getResult.source(), nullValue());
    assertThat(getResult.docIdAndVersion(), notNullValue());

    // make sure we can still work with the engine
    // now do an update
    document = testDocument();
    document.add(new TextField("value", "test1", Field.Store.YES));
    doc =
        testParsedDocument(
            "1", "1", "test", null, -1, -1, document, Lucene.STANDARD_ANALYZER, B_1, false);
    engine.index(new Engine.Index(null, newUid("1"), doc));

    // its not updated yet...
    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 0));
    searchResult.release();

    // refresh and it should be updated
    engine.refresh(new Engine.Refresh(true));

    searchResult = engine.searcher();
    MatcherAssert.assertThat(
        searchResult, EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(1));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test")), 0));
    MatcherAssert.assertThat(
        searchResult,
        EngineSearcherTotalHitsMatcher.engineSearcherTotalHits(
            new TermQuery(new Term("value", "test1")), 1));
    searchResult.release();

    engine.close();
  }
  @Test
  public void testSegments() throws Exception {
    List<Segment> segments = engine.segments();
    assertThat(segments.isEmpty(), equalTo(true));
    final boolean defaultCompound =
        defaultSettings.getAsBoolean(RobinEngine.INDEX_COMPOUND_ON_FLUSH, true);

    // create a doc and refresh
    ParsedDocument doc =
        testParsedDocument(
            "1",
            "1",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_1,
            false);
    engine.create(new Engine.Create(null, newUid("1"), doc));

    ParsedDocument doc2 =
        testParsedDocument(
            "2",
            "2",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_2,
            false);
    engine.create(new Engine.Create(null, newUid("2"), doc2));
    engine.refresh(new Engine.Refresh(true));

    segments = engine.segments();
    assertThat(segments.size(), equalTo(1));
    assertThat(segments.get(0).isCommitted(), equalTo(false));
    assertThat(segments.get(0).isSearch(), equalTo(true));
    assertThat(segments.get(0).getNumDocs(), equalTo(2));
    assertThat(segments.get(0).getDeletedDocs(), equalTo(0));
    assertThat(segments.get(0).isCompound(), equalTo(defaultCompound));

    engine.flush(new Engine.Flush());

    segments = engine.segments();
    assertThat(segments.size(), equalTo(1));
    assertThat(segments.get(0).isCommitted(), equalTo(true));
    assertThat(segments.get(0).isSearch(), equalTo(true));
    assertThat(segments.get(0).getNumDocs(), equalTo(2));
    assertThat(segments.get(0).getDeletedDocs(), equalTo(0));
    assertThat(segments.get(0).isCompound(), equalTo(defaultCompound));

    engineSettingsService.refreshSettings(
        ImmutableSettings.builder().put(RobinEngine.INDEX_COMPOUND_ON_FLUSH, false).build());

    ParsedDocument doc3 =
        testParsedDocument(
            "3",
            "3",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_3,
            false);
    engine.create(new Engine.Create(null, newUid("3"), doc3));
    engine.refresh(new Engine.Refresh(true));

    segments = engine.segments();
    assertThat(segments.size(), equalTo(2));
    assertThat(segments.get(0).getGeneration() < segments.get(1).getGeneration(), equalTo(true));
    assertThat(segments.get(0).isCommitted(), equalTo(true));
    assertThat(segments.get(0).isSearch(), equalTo(true));
    assertThat(segments.get(0).getNumDocs(), equalTo(2));
    assertThat(segments.get(0).getDeletedDocs(), equalTo(0));
    assertThat(segments.get(0).isCompound(), equalTo(defaultCompound));

    assertThat(segments.get(1).isCommitted(), equalTo(false));
    assertThat(segments.get(1).isSearch(), equalTo(true));
    assertThat(segments.get(1).getNumDocs(), equalTo(1));
    assertThat(segments.get(1).getDeletedDocs(), equalTo(0));
    assertThat(segments.get(1).isCompound(), equalTo(false));

    engine.delete(new Engine.Delete("test", "1", newUid("1")));
    engine.refresh(new Engine.Refresh(true));

    segments = engine.segments();
    assertThat(segments.size(), equalTo(2));
    assertThat(segments.get(0).getGeneration() < segments.get(1).getGeneration(), equalTo(true));
    assertThat(segments.get(0).isCommitted(), equalTo(true));
    assertThat(segments.get(0).isSearch(), equalTo(true));
    assertThat(segments.get(0).getNumDocs(), equalTo(1));
    assertThat(segments.get(0).getDeletedDocs(), equalTo(1));
    assertThat(segments.get(0).isCompound(), equalTo(defaultCompound));

    assertThat(segments.get(1).isCommitted(), equalTo(false));
    assertThat(segments.get(1).isSearch(), equalTo(true));
    assertThat(segments.get(1).getNumDocs(), equalTo(1));
    assertThat(segments.get(1).getDeletedDocs(), equalTo(0));
    assertThat(segments.get(1).isCompound(), equalTo(false));

    engineSettingsService.refreshSettings(
        ImmutableSettings.builder().put(RobinEngine.INDEX_COMPOUND_ON_FLUSH, true).build());
    ParsedDocument doc4 =
        testParsedDocument(
            "4",
            "4",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_3,
            false);
    engine.create(new Engine.Create(null, newUid("4"), doc4));
    engine.refresh(new Engine.Refresh(true));

    segments = engine.segments();
    assertThat(segments.size(), equalTo(3));
    assertThat(segments.get(0).getGeneration() < segments.get(1).getGeneration(), equalTo(true));
    assertThat(segments.get(0).isCommitted(), equalTo(true));
    assertThat(segments.get(0).isSearch(), equalTo(true));
    assertThat(segments.get(0).getNumDocs(), equalTo(1));
    assertThat(segments.get(0).getDeletedDocs(), equalTo(1));
    assertThat(segments.get(0).isCompound(), equalTo(defaultCompound));

    assertThat(segments.get(1).isCommitted(), equalTo(false));
    assertThat(segments.get(1).isSearch(), equalTo(true));
    assertThat(segments.get(1).getNumDocs(), equalTo(1));
    assertThat(segments.get(1).getDeletedDocs(), equalTo(0));
    assertThat(segments.get(1).isCompound(), equalTo(false));

    assertThat(segments.get(2).isCommitted(), equalTo(false));
    assertThat(segments.get(2).isSearch(), equalTo(true));
    assertThat(segments.get(2).getNumDocs(), equalTo(1));
    assertThat(segments.get(2).getDeletedDocs(), equalTo(0));
    assertThat(segments.get(2).isCompound(), equalTo(true));
  }
  @Test
  public void testSegments() throws Exception {
    List<Segment> segments = engine.segments();
    assertThat(segments.isEmpty(), equalTo(true));

    // create a doc and refresh
    ParsedDocument doc =
        testParsedDocument(
            "1",
            "1",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_1,
            false);
    engine.create(new Engine.Create(null, newUid("1"), doc));

    ParsedDocument doc2 =
        testParsedDocument(
            "2",
            "2",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_2,
            false);
    engine.create(new Engine.Create(null, newUid("2"), doc2));
    engine.refresh(new Engine.Refresh(true));

    segments = engine.segments();
    assertThat(segments.size(), equalTo(1));
    assertThat(segments.get(0).committed(), equalTo(false));
    assertThat(segments.get(0).search(), equalTo(true));
    assertThat(segments.get(0).numDocs(), equalTo(2));
    assertThat(segments.get(0).deletedDocs(), equalTo(0));

    engine.flush(new Engine.Flush());

    segments = engine.segments();
    assertThat(segments.size(), equalTo(1));
    assertThat(segments.get(0).committed(), equalTo(true));
    assertThat(segments.get(0).search(), equalTo(true));
    assertThat(segments.get(0).numDocs(), equalTo(2));
    assertThat(segments.get(0).deletedDocs(), equalTo(0));

    ParsedDocument doc3 =
        testParsedDocument(
            "3",
            "3",
            "test",
            null,
            -1,
            -1,
            testDocumentWithTextField(),
            Lucene.STANDARD_ANALYZER,
            B_3,
            false);
    engine.create(new Engine.Create(null, newUid("3"), doc3));
    engine.refresh(new Engine.Refresh(true));

    segments = engine.segments();
    assertThat(segments.size(), equalTo(2));
    assertThat(segments.get(0).generation() < segments.get(1).generation(), equalTo(true));
    assertThat(segments.get(0).committed(), equalTo(true));
    assertThat(segments.get(0).search(), equalTo(true));
    assertThat(segments.get(0).numDocs(), equalTo(2));
    assertThat(segments.get(0).deletedDocs(), equalTo(0));

    assertThat(segments.get(1).committed(), equalTo(false));
    assertThat(segments.get(1).search(), equalTo(true));
    assertThat(segments.get(1).numDocs(), equalTo(1));
    assertThat(segments.get(1).deletedDocs(), equalTo(0));

    engine.delete(new Engine.Delete("test", "1", newUid("1")));
    engine.refresh(new Engine.Refresh(true));

    segments = engine.segments();
    assertThat(segments.size(), equalTo(2));
    assertThat(segments.get(0).generation() < segments.get(1).generation(), equalTo(true));
    assertThat(segments.get(0).committed(), equalTo(true));
    assertThat(segments.get(0).search(), equalTo(true));
    assertThat(segments.get(0).numDocs(), equalTo(1));
    assertThat(segments.get(0).deletedDocs(), equalTo(1));

    assertThat(segments.get(1).committed(), equalTo(false));
    assertThat(segments.get(1).search(), equalTo(true));
    assertThat(segments.get(1).numDocs(), equalTo(1));
    assertThat(segments.get(1).deletedDocs(), equalTo(0));
  }