Examples with Version org.apache.lucene.util.Version used on opensource projects

Example 6 with Version

use of org.apache.lucene.util.Version in project lucene-solr by apache.

the class TestClassicSimilarity method testNormEncodingBackwardCompatibility.

public void testNormEncodingBackwardCompatibility() throws IOException {
    Similarity similarity = new ClassicSimilarity();
    for (int indexCreatedVersionMajor : new int[] { Version.LUCENE_6_0_0.major, Version.LATEST.major }) {
        for (int length : new int[] { 1, 4, 16 }) {
            // these length values are encoded accurately on both cases
            Directory dir = newDirectory();
            // set the version on the directory
            new SegmentInfos(indexCreatedVersionMajor).commit(dir);
            IndexWriter w = new IndexWriter(dir, newIndexWriterConfig().setSimilarity(similarity));
            Document doc = new Document();
            String value = IntStream.range(0, length).mapToObj(i -> "b").collect(Collectors.joining(" "));
            doc.add(new TextField("foo", value, Store.NO));
            w.addDocument(doc);
            IndexReader reader = DirectoryReader.open(w);
            IndexSearcher searcher = newSearcher(reader);
            searcher.setSimilarity(similarity);
            Explanation expl = searcher.explain(new TermQuery(new Term("foo", "b")), 0);
            Explanation fieldNorm = findExplanation(expl, "fieldNorm");
            assertNotNull(fieldNorm);
            assertEquals(fieldNorm.toString(), 1 / Math.sqrt(length), fieldNorm.getValue(), 0f);
            w.close();
            reader.close();
            dir.close();
        }
    }
}

Example 7 with Version

use of org.apache.lucene.util.Version in project lucene-solr by apache.

the class FieldTypePluginLoader method readAnalyzer.

//
// <analyzer><tokenizer class="...."/><tokenizer class="...." arg="....">
//
//
private Analyzer readAnalyzer(Node node) throws XPathExpressionException {
    final SolrResourceLoader loader = schema.getResourceLoader();
    if (node == null)
        return null;
    NamedNodeMap attrs = node.getAttributes();
    String analyzerName = DOMUtil.getAttr(attrs, "class");
    // check for all of these up front, so we can error if used in 
    // conjunction with an explicit analyzer class.
    NodeList charFilterNodes = (NodeList) xpath.evaluate("./charFilter", node, XPathConstants.NODESET);
    NodeList tokenizerNodes = (NodeList) xpath.evaluate("./tokenizer", node, XPathConstants.NODESET);
    NodeList tokenFilterNodes = (NodeList) xpath.evaluate("./filter", node, XPathConstants.NODESET);
    if (analyzerName != null) {
        // own custom nodes (ie: <description> or something like that)
        if (0 != charFilterNodes.getLength() || 0 != tokenizerNodes.getLength() || 0 != tokenFilterNodes.getLength()) {
            throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Configuration Error: Analyzer class='" + analyzerName + "' can not be combined with nested analysis factories");
        }
        try {
            // No need to be core-aware as Analyzers are not in the core-aware list
            final Class<? extends Analyzer> clazz = loader.findClass(analyzerName, Analyzer.class);
            Analyzer analyzer = clazz.newInstance();
            final String matchVersionStr = DOMUtil.getAttr(attrs, LUCENE_MATCH_VERSION_PARAM);
            final Version luceneMatchVersion = (matchVersionStr == null) ? schema.getDefaultLuceneMatchVersion() : Config.parseLuceneVersionString(matchVersionStr);
            if (luceneMatchVersion == null) {
                throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Configuration Error: Analyzer '" + clazz.getName() + "' needs a 'luceneMatchVersion' parameter");
            }
            analyzer.setVersion(luceneMatchVersion);
            return analyzer;
        } catch (Exception e) {
            log.error("Cannot load analyzer: " + analyzerName, e);
            throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Cannot load analyzer: " + analyzerName, e);
        }
    }
    // Load the CharFilters
    final ArrayList<CharFilterFactory> charFilters = new ArrayList<>();
    AbstractPluginLoader<CharFilterFactory> charFilterLoader = new AbstractPluginLoader<CharFilterFactory>("[schema.xml] analyzer/charFilter", CharFilterFactory.class, false, false) {

        @Override
        protected CharFilterFactory create(SolrResourceLoader loader, String name, String className, Node node) throws Exception {
            final Map<String, String> params = DOMUtil.toMap(node.getAttributes());
            String configuredVersion = params.remove(LUCENE_MATCH_VERSION_PARAM);
            params.put(LUCENE_MATCH_VERSION_PARAM, parseConfiguredVersion(configuredVersion, CharFilterFactory.class.getSimpleName()).toString());
            CharFilterFactory factory = loader.newInstance(className, CharFilterFactory.class, getDefaultPackages(), new Class[] { Map.class }, new Object[] { params });
            factory.setExplicitLuceneMatchVersion(null != configuredVersion);
            return factory;
        }

        @Override
        protected void init(CharFilterFactory plugin, Node node) throws Exception {
            if (plugin != null) {
                charFilters.add(plugin);
            }
        }

        @Override
        protected CharFilterFactory register(String name, CharFilterFactory plugin) {
            // used for map registration
            return null;
        }
    };
    charFilterLoader.load(loader, charFilterNodes);
    // Load the Tokenizer
    // Although an analyzer only allows a single Tokenizer, we load a list to make sure
    // the configuration is ok
    final ArrayList<TokenizerFactory> tokenizers = new ArrayList<>(1);
    AbstractPluginLoader<TokenizerFactory> tokenizerLoader = new AbstractPluginLoader<TokenizerFactory>("[schema.xml] analyzer/tokenizer", TokenizerFactory.class, false, false) {

        @Override
        protected TokenizerFactory create(SolrResourceLoader loader, String name, String className, Node node) throws Exception {
            final Map<String, String> params = DOMUtil.toMap(node.getAttributes());
            String configuredVersion = params.remove(LUCENE_MATCH_VERSION_PARAM);
            params.put(LUCENE_MATCH_VERSION_PARAM, parseConfiguredVersion(configuredVersion, TokenizerFactory.class.getSimpleName()).toString());
            TokenizerFactory factory = loader.newInstance(className, TokenizerFactory.class, getDefaultPackages(), new Class[] { Map.class }, new Object[] { params });
            factory.setExplicitLuceneMatchVersion(null != configuredVersion);
            return factory;
        }

        @Override
        protected void init(TokenizerFactory plugin, Node node) throws Exception {
            if (!tokenizers.isEmpty()) {
                throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "The schema defines multiple tokenizers for: " + node);
            }
            tokenizers.add(plugin);
        }

        @Override
        protected TokenizerFactory register(String name, TokenizerFactory plugin) {
            // used for map registration
            return null;
        }
    };
    tokenizerLoader.load(loader, tokenizerNodes);
    // Make sure something was loaded
    if (tokenizers.isEmpty()) {
        throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "analyzer without class or tokenizer");
    }
    // Load the Filters
    final ArrayList<TokenFilterFactory> filters = new ArrayList<>();
    AbstractPluginLoader<TokenFilterFactory> filterLoader = new AbstractPluginLoader<TokenFilterFactory>("[schema.xml] analyzer/filter", TokenFilterFactory.class, false, false) {

        @Override
        protected TokenFilterFactory create(SolrResourceLoader loader, String name, String className, Node node) throws Exception {
            final Map<String, String> params = DOMUtil.toMap(node.getAttributes());
            String configuredVersion = params.remove(LUCENE_MATCH_VERSION_PARAM);
            params.put(LUCENE_MATCH_VERSION_PARAM, parseConfiguredVersion(configuredVersion, TokenFilterFactory.class.getSimpleName()).toString());
            TokenFilterFactory factory = loader.newInstance(className, TokenFilterFactory.class, getDefaultPackages(), new Class[] { Map.class }, new Object[] { params });
            factory.setExplicitLuceneMatchVersion(null != configuredVersion);
            return factory;
        }

        @Override
        protected void init(TokenFilterFactory plugin, Node node) throws Exception {
            if (plugin != null) {
                filters.add(plugin);
            }
        }

        @Override
        protected TokenFilterFactory register(String name, TokenFilterFactory plugin) throws Exception {
            // used for map registration
            return null;
        }
    };
    filterLoader.load(loader, tokenFilterNodes);
    return new TokenizerChain(charFilters.toArray(new CharFilterFactory[charFilters.size()]), tokenizers.get(0), filters.toArray(new TokenFilterFactory[filters.size()]));
}

Example 8 with Version

use of org.apache.lucene.util.Version in project elasticsearch by elastic.

the class RecoveryFileChunkRequest method readFrom.

@Override
public void readFrom(StreamInput in) throws IOException {
    super.readFrom(in);
    recoveryId = in.readLong();
    shardId = ShardId.readShardId(in);
    String name = in.readString();
    position = in.readVLong();
    long length = in.readVLong();
    String checksum = in.readString();
    content = in.readBytesReference();
    Version writtenBy = Lucene.parseVersionLenient(in.readString(), null);
    assert writtenBy != null;
    metaData = new StoreFileMetaData(name, length, checksum, writtenBy);
    lastChunk = in.readBoolean();
    totalTranslogOps = in.readVInt();
    sourceThrottleTimeInNanos = in.readLong();
}

Example 9 with Version

use of org.apache.lucene.util.Version in project lucene-solr by apache.

the class CheckIndex method checkIndex.

/** Returns a {@link Status} instance detailing
   *  the state of the index.
   * 
   *  @param onlySegments list of specific segment names to check
   *
   *  <p>As this method checks every byte in the specified
   *  segments, on a large index it can take quite a long
   *  time to run. */
public Status checkIndex(List<String> onlySegments) throws IOException {
    ensureOpen();
    long startNS = System.nanoTime();
    NumberFormat nf = NumberFormat.getInstance(Locale.ROOT);
    SegmentInfos sis = null;
    Status result = new Status();
    result.dir = dir;
    String[] files = dir.listAll();
    String lastSegmentsFile = SegmentInfos.getLastCommitSegmentsFileName(files);
    if (lastSegmentsFile == null) {
        throw new IndexNotFoundException("no segments* file found in " + dir + ": files: " + Arrays.toString(files));
    }
    try {
        // Do not use SegmentInfos.read(Directory) since the spooky
        // retrying it does is not necessary here (we hold the write lock):
        sis = SegmentInfos.readCommit(dir, lastSegmentsFile);
    } catch (Throwable t) {
        if (failFast) {
            throw IOUtils.rethrowAlways(t);
        }
        msg(infoStream, "ERROR: could not read any segments file in directory");
        result.missingSegments = true;
        if (infoStream != null)
            t.printStackTrace(infoStream);
        return result;
    }
    // find the oldest and newest segment versions
    Version oldest = null;
    Version newest = null;
    String oldSegs = null;
    for (SegmentCommitInfo si : sis) {
        Version version = si.info.getVersion();
        if (version == null) {
            // pre-3.1 segment
            oldSegs = "pre-3.1";
        } else {
            if (oldest == null || version.onOrAfter(oldest) == false) {
                oldest = version;
            }
            if (newest == null || version.onOrAfter(newest)) {
                newest = version;
            }
        }
    }
    final int numSegments = sis.size();
    final String segmentsFileName = sis.getSegmentsFileName();
    // note: we only read the format byte (required preamble) here!
    IndexInput input = null;
    try {
        input = dir.openInput(segmentsFileName, IOContext.READONCE);
    } catch (Throwable t) {
        if (failFast) {
            throw IOUtils.rethrowAlways(t);
        }
        msg(infoStream, "ERROR: could not open segments file in directory");
        if (infoStream != null) {
            t.printStackTrace(infoStream);
        }
        result.cantOpenSegments = true;
        return result;
    }
    try {
        /*int format =*/
        input.readInt();
    } catch (Throwable t) {
        if (failFast) {
            throw IOUtils.rethrowAlways(t);
        }
        msg(infoStream, "ERROR: could not read segment file version in directory");
        if (infoStream != null) {
            t.printStackTrace(infoStream);
        }
        result.missingSegmentVersion = true;
        return result;
    } finally {
        if (input != null)
            input.close();
    }
    result.segmentsFileName = segmentsFileName;
    result.numSegments = numSegments;
    result.userData = sis.getUserData();
    String userDataString;
    if (sis.getUserData().size() > 0) {
        userDataString = " userData=" + sis.getUserData();
    } else {
        userDataString = "";
    }
    String versionString = "";
    if (oldSegs != null) {
        if (newest != null) {
            versionString = "versions=[" + oldSegs + " .. " + newest + "]";
        } else {
            versionString = "version=" + oldSegs;
        }
    } else if (newest != null) {
        // implies oldest != null
        versionString = oldest.equals(newest) ? ("version=" + oldest) : ("versions=[" + oldest + " .. " + newest + "]");
    }
    msg(infoStream, "Segments file=" + segmentsFileName + " numSegments=" + numSegments + " " + versionString + " id=" + StringHelper.idToString(sis.getId()) + userDataString);
    if (onlySegments != null) {
        result.partial = true;
        if (infoStream != null) {
            infoStream.print("\nChecking only these segments:");
            for (String s : onlySegments) {
                infoStream.print(" " + s);
            }
        }
        result.segmentsChecked.addAll(onlySegments);
        msg(infoStream, ":");
    }
    result.newSegments = sis.clone();
    result.newSegments.clear();
    result.maxSegmentName = -1;
    for (int i = 0; i < numSegments; i++) {
        final SegmentCommitInfo info = sis.info(i);
        int segmentName = Integer.parseInt(info.info.name.substring(1), Character.MAX_RADIX);
        if (segmentName > result.maxSegmentName) {
            result.maxSegmentName = segmentName;
        }
        if (onlySegments != null && !onlySegments.contains(info.info.name)) {
            continue;
        }
        Status.SegmentInfoStatus segInfoStat = new Status.SegmentInfoStatus();
        result.segmentInfos.add(segInfoStat);
        msg(infoStream, "  " + (1 + i) + " of " + numSegments + ": name=" + info.info.name + " maxDoc=" + info.info.maxDoc());
        segInfoStat.name = info.info.name;
        segInfoStat.maxDoc = info.info.maxDoc();
        final Version version = info.info.getVersion();
        if (info.info.maxDoc() <= 0) {
            throw new RuntimeException("illegal number of documents: maxDoc=" + info.info.maxDoc());
        }
        int toLoseDocCount = info.info.maxDoc();
        SegmentReader reader = null;
        Sort previousIndexSort = null;
        try {
            msg(infoStream, "    version=" + (version == null ? "3.0" : version));
            msg(infoStream, "    id=" + StringHelper.idToString(info.info.getId()));
            final Codec codec = info.info.getCodec();
            msg(infoStream, "    codec=" + codec);
            segInfoStat.codec = codec;
            msg(infoStream, "    compound=" + info.info.getUseCompoundFile());
            segInfoStat.compound = info.info.getUseCompoundFile();
            msg(infoStream, "    numFiles=" + info.files().size());
            Sort indexSort = info.info.getIndexSort();
            if (indexSort != null) {
                msg(infoStream, "    sort=" + indexSort);
                if (previousIndexSort != null) {
                    if (previousIndexSort.equals(indexSort) == false) {
                        throw new RuntimeException("index sort changed from " + previousIndexSort + " to " + indexSort);
                    }
                } else {
                    previousIndexSort = indexSort;
                }
            }
            segInfoStat.numFiles = info.files().size();
            segInfoStat.sizeMB = info.sizeInBytes() / (1024. * 1024.);
            msg(infoStream, "    size (MB)=" + nf.format(segInfoStat.sizeMB));
            Map<String, String> diagnostics = info.info.getDiagnostics();
            segInfoStat.diagnostics = diagnostics;
            if (diagnostics.size() > 0) {
                msg(infoStream, "    diagnostics = " + diagnostics);
            }
            if (!info.hasDeletions()) {
                msg(infoStream, "    no deletions");
                segInfoStat.hasDeletions = false;
            } else {
                msg(infoStream, "    has deletions [delGen=" + info.getDelGen() + "]");
                segInfoStat.hasDeletions = true;
                segInfoStat.deletionsGen = info.getDelGen();
            }
            long startOpenReaderNS = System.nanoTime();
            if (infoStream != null)
                infoStream.print("    test: open reader.........");
            reader = new SegmentReader(info, sis.getIndexCreatedVersionMajor(), IOContext.DEFAULT);
            msg(infoStream, String.format(Locale.ROOT, "OK [took %.3f sec]", nsToSec(System.nanoTime() - startOpenReaderNS)));
            segInfoStat.openReaderPassed = true;
            long startIntegrityNS = System.nanoTime();
            if (infoStream != null)
                infoStream.print("    test: check integrity.....");
            reader.checkIntegrity();
            msg(infoStream, String.format(Locale.ROOT, "OK [took %.3f sec]", nsToSec(System.nanoTime() - startIntegrityNS)));
            if (reader.maxDoc() != info.info.maxDoc()) {
                throw new RuntimeException("SegmentReader.maxDoc() " + reader.maxDoc() + " != SegmentInfo.maxDoc " + info.info.maxDoc());
            }
            final int numDocs = reader.numDocs();
            toLoseDocCount = numDocs;
            if (reader.hasDeletions()) {
                if (reader.numDocs() != info.info.maxDoc() - info.getDelCount()) {
                    throw new RuntimeException("delete count mismatch: info=" + (info.info.maxDoc() - info.getDelCount()) + " vs reader=" + reader.numDocs());
                }
                if ((info.info.maxDoc() - reader.numDocs()) > reader.maxDoc()) {
                    throw new RuntimeException("too many deleted docs: maxDoc()=" + reader.maxDoc() + " vs del count=" + (info.info.maxDoc() - reader.numDocs()));
                }
                if (info.info.maxDoc() - reader.numDocs() != info.getDelCount()) {
                    throw new RuntimeException("delete count mismatch: info=" + info.getDelCount() + " vs reader=" + (info.info.maxDoc() - reader.numDocs()));
                }
            } else {
                if (info.getDelCount() != 0) {
                    throw new RuntimeException("delete count mismatch: info=" + info.getDelCount() + " vs reader=" + (info.info.maxDoc() - reader.numDocs()));
                }
            }
            if (checksumsOnly == false) {
                // Test Livedocs
                segInfoStat.liveDocStatus = testLiveDocs(reader, infoStream, failFast);
                // Test Fieldinfos
                segInfoStat.fieldInfoStatus = testFieldInfos(reader, infoStream, failFast);
                // Test Field Norms
                segInfoStat.fieldNormStatus = testFieldNorms(reader, infoStream, failFast);
                // Test the Term Index
                segInfoStat.termIndexStatus = testPostings(reader, infoStream, verbose, failFast, version);
                // Test Stored Fields
                segInfoStat.storedFieldStatus = testStoredFields(reader, infoStream, failFast);
                // Test Term Vectors
                segInfoStat.termVectorStatus = testTermVectors(reader, infoStream, verbose, crossCheckTermVectors, failFast, version);
                // Test Docvalues
                segInfoStat.docValuesStatus = testDocValues(reader, infoStream, failFast);
                // Test PointValues
                segInfoStat.pointsStatus = testPoints(reader, infoStream, failFast);
                // Test index sort
                segInfoStat.indexSortStatus = testSort(reader, indexSort, infoStream, failFast);
                //  This will cause stats for failed segments to be incremented properly
                if (segInfoStat.liveDocStatus.error != null) {
                    throw new RuntimeException("Live docs test failed");
                } else if (segInfoStat.fieldInfoStatus.error != null) {
                    throw new RuntimeException("Field Info test failed");
                } else if (segInfoStat.fieldNormStatus.error != null) {
                    throw new RuntimeException("Field Norm test failed");
                } else if (segInfoStat.termIndexStatus.error != null) {
                    throw new RuntimeException("Term Index test failed");
                } else if (segInfoStat.storedFieldStatus.error != null) {
                    throw new RuntimeException("Stored Field test failed");
                } else if (segInfoStat.termVectorStatus.error != null) {
                    throw new RuntimeException("Term Vector test failed");
                } else if (segInfoStat.docValuesStatus.error != null) {
                    throw new RuntimeException("DocValues test failed");
                } else if (segInfoStat.pointsStatus.error != null) {
                    throw new RuntimeException("Points test failed");
                }
            }
            msg(infoStream, "");
            if (verbose) {
                msg(infoStream, "detailed segment RAM usage: ");
                msg(infoStream, Accountables.toString(reader));
            }
        } catch (Throwable t) {
            if (failFast) {
                throw IOUtils.rethrowAlways(t);
            }
            msg(infoStream, "FAILED");
            String comment;
            comment = "exorciseIndex() would remove reference to this segment";
            msg(infoStream, "    WARNING: " + comment + "; full exception:");
            if (infoStream != null)
                t.printStackTrace(infoStream);
            msg(infoStream, "");
            result.totLoseDocCount += toLoseDocCount;
            result.numBadSegments++;
            continue;
        } finally {
            if (reader != null)
                reader.close();
        }
        // Keeper
        result.newSegments.add(info.clone());
    }
    if (0 == result.numBadSegments) {
        result.clean = true;
    } else
        msg(infoStream, "WARNING: " + result.numBadSegments + " broken segments (containing " + result.totLoseDocCount + " documents) detected");
    if (!(result.validCounter = (result.maxSegmentName < sis.counter))) {
        result.clean = false;
        result.newSegments.counter = result.maxSegmentName + 1;
        msg(infoStream, "ERROR: Next segment name counter " + sis.counter + " is not greater than max segment name " + result.maxSegmentName);
    }
    if (result.clean) {
        msg(infoStream, "No problems were detected with this index.\n");
    }
    msg(infoStream, String.format(Locale.ROOT, "Took %.3f sec total.", nsToSec(System.nanoTime() - startNS)));
    return result;
}

Example 10 with Version

use of org.apache.lucene.util.Version in project lucene-solr by apache.

the class TestBackwardsCompatibility method testAllVersionsTested.

public void testAllVersionsTested() throws Exception {
    Pattern constantPattern = Pattern.compile("LUCENE_(\\d+)_(\\d+)_(\\d+)(_ALPHA|_BETA)?");
    // find the unique versions according to Version.java
    List<String> expectedVersions = new ArrayList<>();
    for (java.lang.reflect.Field field : Version.class.getDeclaredFields()) {
        if (Modifier.isStatic(field.getModifiers()) && field.getType() == Version.class) {
            Version v = (Version) field.get(Version.class);
            if (v.equals(Version.LATEST)) {
                continue;
            }
            Matcher constant = constantPattern.matcher(field.getName());
            if (constant.matches() == false) {
                continue;
            }
            expectedVersions.add(v.toString() + "-cfs");
        }
    }
    // BEGIN TRUNK ONLY BLOCK
    // on trunk, the last release of the prev major release is also untested
    Version lastPrevMajorVersion = null;
    for (java.lang.reflect.Field field : Version.class.getDeclaredFields()) {
        if (Modifier.isStatic(field.getModifiers()) && field.getType() == Version.class) {
            Version v = (Version) field.get(Version.class);
            Matcher constant = constantPattern.matcher(field.getName());
            if (constant.matches() == false)
                continue;
            if (v.major == Version.LATEST.major - 1 && (lastPrevMajorVersion == null || v.onOrAfter(lastPrevMajorVersion))) {
                lastPrevMajorVersion = v;
            }
        }
    }
    assertNotNull(lastPrevMajorVersion);
    expectedVersions.remove(lastPrevMajorVersion.toString() + "-cfs");
    // END TRUNK ONLY BLOCK
    Collections.sort(expectedVersions);
    // find what versions we are testing
    List<String> testedVersions = new ArrayList<>();
    for (String testedVersion : oldNames) {
        if (testedVersion.endsWith("-cfs") == false) {
            continue;
        }
        testedVersions.add(testedVersion);
    }
    Collections.sort(testedVersions);
    int i = 0;
    int j = 0;
    List<String> missingFiles = new ArrayList<>();
    List<String> extraFiles = new ArrayList<>();
    while (i < expectedVersions.size() && j < testedVersions.size()) {
        String expectedVersion = expectedVersions.get(i);
        String testedVersion = testedVersions.get(j);
        int compare = expectedVersion.compareTo(testedVersion);
        if (compare == 0) {
            // equal, we can move on
            ++i;
            ++j;
        } else if (compare < 0) {
            // didn't find test for version constant
            missingFiles.add(expectedVersion);
            ++i;
        } else {
            // extra test file
            extraFiles.add(testedVersion);
            ++j;
        }
    }
    while (i < expectedVersions.size()) {
        missingFiles.add(expectedVersions.get(i));
        ++i;
    }
    while (j < testedVersions.size()) {
        missingFiles.add(testedVersions.get(j));
        ++j;
    }
    // we could be missing up to 1 file, which may be due to a release that is in progress
    if (missingFiles.size() <= 1 && extraFiles.isEmpty()) {
        // success
        return;
    }
    StringBuffer msg = new StringBuffer();
    if (missingFiles.size() > 1) {
        msg.append("Missing backcompat test files:\n");
        for (String missingFile : missingFiles) {
            msg.append("  " + missingFile + "\n");
        }
    }
    if (extraFiles.isEmpty() == false) {
        msg.append("Extra backcompat test files:\n");
        for (String extraFile : extraFiles) {
            msg.append("  " + extraFile + "\n");
        }
    }
    fail(msg.toString());
}