From a64ef7400f0e7428a78bfb5ddebb815442e30ca1 Mon Sep 17 00:00:00 2001 From: Shai Erera Date: Wed, 23 Jan 2013 11:14:06 +0000 Subject: [PATCH] LUCENE-4709: remove FacetResultNode.residue git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1437345 13f79535-47bb-0310-9956-ffa450edef68 --- lucene/CHANGES.txt | 4 ++ .../search/AdaptiveFacetsAccumulator.java | 4 +- .../facet/search/CountingFacetsCollector.java | 6 --- .../lucene/facet/search/SamplingWrapper.java | 4 +- .../facet/search/TopKFacetResultsHandler.java | 12 +----- .../facet/search/TopKInEachNodeHandler.java | 33 ++++------------ .../facet/search/results/FacetResultNode.java | 11 ------ .../lucene/facet/search/sampling/Sampler.java | 14 +------ .../search/sampling/SamplingAccumulator.java | 4 +- .../search/CountingFacetsCollectorTest.java | 37 ------------------ .../TestTopKInEachNodeResultHandler.java | 38 +++++-------------- 11 files changed, 26 insertions(+), 141 deletions(-) diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt index 65b581ba4c3..2d9a1b48a69 100644 --- a/lucene/CHANGES.txt +++ b/lucene/CHANGES.txt @@ -64,6 +64,10 @@ New Features * LUCENE-4599: New oal.codecs.compressing.CompressingTermVectorsFormat which compresses term vectors into chunks of documents similarly to CompressingStoredFieldsFormat. (Adrien Grand) + +API Changes + +* LUCENE-4709: FacetResultNode no longer has a residue field. (Shai Erera) Bug Fixes diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/AdaptiveFacetsAccumulator.java b/lucene/facet/src/java/org/apache/lucene/facet/search/AdaptiveFacetsAccumulator.java index 09bb7f049f3..d433f52add2 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/AdaptiveFacetsAccumulator.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/AdaptiveFacetsAccumulator.java @@ -5,7 +5,6 @@ import java.util.List; import org.apache.lucene.facet.search.params.FacetSearchParams; import org.apache.lucene.facet.search.results.FacetResult; -import org.apache.lucene.facet.search.results.FacetResultNode; import org.apache.lucene.facet.search.sampling.RandomSampler; import org.apache.lucene.facet.search.sampling.Sampler; import org.apache.lucene.facet.search.sampling.SamplingAccumulator; @@ -37,8 +36,7 @@ import org.apache.lucene.index.IndexReader; *

* Note: Sampling accumulation (Accumulation over a sampled-set of the results), * does not guarantee accurate values for - * {@link FacetResult#getNumValidDescendants()} and - * {@link FacetResultNode#residue}. + * {@link FacetResult#getNumValidDescendants()}. * * @lucene.experimental */ diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/CountingFacetsCollector.java b/lucene/facet/src/java/org/apache/lucene/facet/search/CountingFacetsCollector.java index a82d8d8a1dd..0c6363ebb60 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/CountingFacetsCollector.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/CountingFacetsCollector.java @@ -262,7 +262,6 @@ public class CountingFacetsCollector extends FacetsCollector { } child = siblings[child]; } - root.residue = 0; root.subResults = nodes; res.add(new FacetResult(fr, root, nodes.size())); continue; @@ -273,17 +272,13 @@ public class CountingFacetsCollector extends FacetsCollector { FacetResultNode top = pq.top(); int child = children[rootOrd]; int numResults = 0; // count the number of results - int residue = 0; while (child != TaxonomyReader.INVALID_ORDINAL) { int count = counts[child]; if (count > top.value) { - residue += top.value; top.value = count; top.ordinal = child; top = pq.updateTop(); ++numResults; - } else { - residue += count; } child = siblings[child]; } @@ -300,7 +295,6 @@ public class CountingFacetsCollector extends FacetsCollector { node.label = taxoReader.getPath(node.ordinal); subResults[i] = node; } - root.residue = residue; root.subResults = Arrays.asList(subResults); res.add(new FacetResult(fr, root, size)); } diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/SamplingWrapper.java b/lucene/facet/src/java/org/apache/lucene/facet/search/SamplingWrapper.java index 67e466c3b2c..e2087c0fcb8 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/SamplingWrapper.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/SamplingWrapper.java @@ -6,7 +6,6 @@ import java.util.List; import org.apache.lucene.facet.search.params.FacetSearchParams; import org.apache.lucene.facet.search.results.FacetResult; -import org.apache.lucene.facet.search.results.FacetResultNode; import org.apache.lucene.facet.search.sampling.Sampler; import org.apache.lucene.facet.search.sampling.Sampler.SampleResult; @@ -32,8 +31,7 @@ import org.apache.lucene.facet.search.sampling.Sampler.SampleResult; *

* Note: Sampling accumulation (Accumulation over a sampled-set of the results), * does not guarantee accurate values for - * {@link FacetResult#getNumValidDescendants()} and - * {@link FacetResultNode#residue}. + * {@link FacetResult#getNumValidDescendants()}. * * @lucene.experimental */ diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/TopKFacetResultsHandler.java b/lucene/facet/src/java/org/apache/lucene/facet/search/TopKFacetResultsHandler.java index 7abf36e915a..8b1ea9f94de 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/TopKFacetResultsHandler.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/TopKFacetResultsHandler.java @@ -62,7 +62,6 @@ public class TopKFacetResultsHandler extends FacetResultsHandler { value = facetRequest.getValueOf(facetArrays, ordinal % partitionSize); } - // TODO (Facet): should initial value of "residue" depend on aggregator if not sum? FacetResultNode parentResultNode = new FacetResultNode(ordinal, value); Heap heap = ResultSortUtils.createSuitableHeap(facetRequest); @@ -97,11 +96,7 @@ public class TopKFacetResultsHandler extends FacetResultsHandler { } // bring sub results from heap of tmp res into result heap for (int i = tmpHeap.size(); i > 0; i--) { - - FacetResultNode a = heap.insertWithOverflow(tmpHeap.pop()); - if (a != null) { - resNode.residue += a.residue; - } + heap.insertWithOverflow(tmpHeap.pop()); } } @@ -177,14 +172,9 @@ public class TopKFacetResultsHandler extends FacetResultsHandler { reusable.value = value; reusable.subResults.clear(); reusable.label = null; - reusable.residue = 0; } ++childrenCounter; reusable = pq.insertWithOverflow(reusable); - if (reusable != null) { - // TODO (Facet): is other logic (not add) needed, per aggregator? - parentResultNode.residue += reusable.value; - } } } if (localDepth < depth) { diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/TopKInEachNodeHandler.java b/lucene/facet/src/java/org/apache/lucene/facet/search/TopKInEachNodeHandler.java index fbcf62d482d..124d13360aa 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/TopKInEachNodeHandler.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/TopKInEachNodeHandler.java @@ -266,9 +266,7 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { tosOrdinal = siblings[tosOrdinal]; } // now it is inside. Run it and all its siblings inside the partition through a heap - // and in doing so, count them, find best K, and sum into residue - double residue = 0f; // the sum of all the siblings from this partition that do not make - // it to top K + // and in doing so, count them, find best K pq.clear(); //reusables are consumed as from a stack. The stack starts full and returns full. @@ -286,10 +284,6 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { ac.value = value; ac = pq.insertWithOverflow(ac); if (null != ac) { - residue += ac.value; - // TODO (Facet): could it be that we need to do something - // else, not add, depending on the aggregator? - /* when a facet is excluded from top K, because already in this partition it has * K better siblings, it is only recursed for count only. */ @@ -320,7 +314,7 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { // and add ords to sibling stack, and make a note in siblingExplored that these are to // be visited now if (ords.length > 0) { - AACOsOfOnePartition.put(ordinalStack[localDepth-1], new AACO(ords,vals,residue)); + AACOsOfOnePartition.put(ordinalStack[localDepth-1], new AACO(ords,vals)); bestSignlingsStack[localDepth] = ords; siblingExplored[localDepth] = ords.length-1; ordinalStack[localDepth] = ords[ords.length-1]; @@ -449,8 +443,7 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { IntToObjectMap tmpToReturnMapToACCOs = tmpToReturn.mapToAACOs; IntToObjectMap tfrMapToACCOs = tfr.mapToAACOs; IntIterator tfrIntIterator = tfrMapToACCOs.keyIterator(); - //iterate over all ordinals in tfr that are maps to their children (and the residue over - // non included chilren) + //iterate over all ordinals in tfr that are maps to their children while (tfrIntIterator.hasNext()) { int tfrkey = tfrIntIterator.next(); AACO tmpToReturnAACO = null; @@ -467,7 +460,6 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { } int[] resOrds = new int [resLength]; double[] resVals = new double [resLength]; - double resResidue = tmpToReturnAACO.residue + tfrAACO.residue; int indexIntoTmpToReturn = 0; int indexIntoTFR = 0; ACComparator merger = getSuitableACComparator(); // by facet Request @@ -504,15 +496,9 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { // altogether yielding no more that best K kids for tfrkey, not to appear in the new shape of // tmpToReturn - while (indexIntoTmpToReturn < tmpToReturnAACO.ordinals.length) { - resResidue += tmpToReturnAACO.values[indexIntoTmpToReturn++]; - } - while (indexIntoTFR < tfrAACO.ordinals.length) { - resResidue += tfrAACO.values[indexIntoTFR++]; - } //update the list of best kids of tfrkey as appear in tmpToReturn - tmpToReturnMapToACCOs.put(tfrkey, new AACO(resOrds, resVals, resResidue)); - } // endof need to merge both AACO -- children and residue for same ordinal + tmpToReturnMapToACCOs.put(tfrkey, new AACO(resOrds, resVals)); + } // endof need to merge both AACO -- children for same ordinal } // endof loop over all ordinals in tfr } // endof loop over all temporary facet results to merge @@ -682,19 +668,15 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { * potential nodes of the {@link FacetResult} tree * (i.e., the descendants of the root node, no deeper than the specified depth). * No more than K ( = {@link FacetRequest#getNumResults()}) - * siblings are enumerated, and - * residue holds the sum of values of the siblings rejected from the - * enumerated top K. + * siblings are enumerated. * @lucene.internal */ protected static final class AACO { int [] ordinals; // ordinals of the best K children, sorted from best to least double [] values; // the respective values for these children - double residue; // sum of values of all other children, that did not get into top K - AACO (int[] ords, double[] vals, double r) { + AACO (int[] ords, double[] vals) { this.ordinals = ords; this.values = vals; - this.residue = r; } } @@ -787,7 +769,6 @@ public class TopKInEachNodeHandler extends FacetResultsHandler { list.add(generateNode(aaco.ordinals[i], aaco.values[i], mapToAACOs)); } node.subResults = list; - node.residue = aaco.residue; return node; } diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/results/FacetResultNode.java b/lucene/facet/src/java/org/apache/lucene/facet/search/results/FacetResultNode.java index 7a485152313..e6dde2a3629 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/results/FacetResultNode.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/results/FacetResultNode.java @@ -58,14 +58,6 @@ public class FacetResultNode { */ public double value; - /** - * The total value of screened out sub results. If only part of the results - * were returned (usually because only the top-K categories are requested), - * then this provides information on "what else is there under this result - * node". - */ - public double residue; - /** * The sub-results of this result. If {@link FacetRequest#getResultMode()} is * {@link ResultMode#PER_NODE_IN_TREE}, every sub result denotes an immediate @@ -100,9 +92,6 @@ public class FacetResultNode { sb.append(label.toString()); } sb.append(" (").append(Double.toString(value)).append(")"); - if (residue > 0) { - sb.append(" (residue=").append(residue).append(")"); - } for (FacetResultNode sub : subResults) { sb.append("\n").append(prefix).append(sub.toString(prefix + " ")); } diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/Sampler.java b/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/Sampler.java index 488c20406fa..5858164b4d8 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/Sampler.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/Sampler.java @@ -39,8 +39,7 @@ import org.apache.lucene.index.IndexReader; *

* Note: Sampling accumulation (Accumulation over a sampled-set of the results), * does not guarantee accurate values for - * {@link FacetResult#getNumValidDescendants()} & - * {@link FacetResultNode#residue}. + * {@link FacetResult#getNumValidDescendants()}. * * @lucene.experimental */ @@ -187,17 +186,6 @@ public abstract class Sampler { trimmed.add(trimmedNode); } - /* - * If we are trimming, it means Sampling is in effect and the extra - * (over-sampled) results are being trimmed. Although the residue is not - * guaranteed to be accurate for Sampling, we try our best to fix it. - * The node's residue now will take under account the sub-nodes we're - * trimming. - */ - for (int i = size; i < node.subResults.size(); i++) { - node.residue += node.subResults.get(i).value; - } - node.subResults = trimmed; } diff --git a/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/SamplingAccumulator.java b/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/SamplingAccumulator.java index 7afc5565218..efcaa1a5261 100644 --- a/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/SamplingAccumulator.java +++ b/lucene/facet/src/java/org/apache/lucene/facet/search/sampling/SamplingAccumulator.java @@ -12,7 +12,6 @@ import org.apache.lucene.facet.search.ScoredDocIDs; import org.apache.lucene.facet.search.StandardFacetsAccumulator; import org.apache.lucene.facet.search.params.FacetSearchParams; import org.apache.lucene.facet.search.results.FacetResult; -import org.apache.lucene.facet.search.results.FacetResultNode; import org.apache.lucene.facet.search.sampling.Sampler.SampleResult; import org.apache.lucene.facet.taxonomy.TaxonomyReader; import org.apache.lucene.index.IndexReader; @@ -48,8 +47,7 @@ import org.apache.lucene.index.IndexReader; *

* Note: Sampling accumulation (Accumulation over a sampled-set of the results), * does not guarantee accurate values for - * {@link FacetResult#getNumValidDescendants()} & - * {@link FacetResultNode#residue}. + * {@link FacetResult#getNumValidDescendants()}. * * @see Sampler * @lucene.experimental diff --git a/lucene/facet/src/test/org/apache/lucene/facet/search/CountingFacetsCollectorTest.java b/lucene/facet/src/test/org/apache/lucene/facet/search/CountingFacetsCollectorTest.java index f03a4701852..4ce2e56dad7 100644 --- a/lucene/facet/src/test/org/apache/lucene/facet/search/CountingFacetsCollectorTest.java +++ b/lucene/facet/src/test/org/apache/lucene/facet/search/CountingFacetsCollectorTest.java @@ -328,39 +328,6 @@ public class CountingFacetsCollectorTest extends LuceneTestCase { for (FacetResult res : facetResults) { FacetResultNode root = res.getFacetResultNode(); assertEquals("wrong count for " + root.label, termExpectedCounts.get(root.label), (int) root.value); - assertEquals("invalid residue", 0, (int) root.residue); - for (FacetResultNode child : root.subResults) { - assertEquals("wrong count for " + child.label, termExpectedCounts.get(child.label), (int) child.value); - } - } - - IOUtils.close(indexReader, taxoReader); - } - - @Test - public void testResidue() throws Exception { - // test the collector's handling of residue - DirectoryReader indexReader = DirectoryReader.open(indexDir); - TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir); - IndexSearcher searcher = new IndexSearcher(indexReader); - - // asking for top 1 is the only way to guarantee there will be a residue - // provided that enough children were indexed (see below) - FacetSearchParams fsp = new FacetSearchParams(new CountFacetRequest(CP_A, 1), new CountFacetRequest(CP_B, 1)); - FacetsCollector fc = new CountingFacetsCollector(fsp , taxoReader); - TermQuery q = new TermQuery(A); - searcher.search(q, fc); - - List facetResults = fc.getFacetResults(); - assertEquals("invalid number of facet results", 2, facetResults.size()); - for (FacetResult res : facetResults) { - FacetResultNode root = res.getFacetResultNode(); - assertEquals("wrong count for " + root.label, termExpectedCounts.get(root.label), (int) root.value); - // make sure randomness didn't pick only one child of root (otherwise there's no residue) - int numChildrenIndexed = res.getFacetRequest().categoryPath == CP_A ? numChildrenIndexedA : numChildrenIndexedB; - if (numChildrenIndexed > 1) { - assertTrue("expected residue", root.residue > 0); - } for (FacetResultNode child : root.subResults) { assertEquals("wrong count for " + child.label, termExpectedCounts.get(child.label), (int) child.value); } @@ -385,7 +352,6 @@ public class CountingFacetsCollectorTest extends LuceneTestCase { for (FacetResult res : facetResults) { FacetResultNode root = res.getFacetResultNode(); assertEquals("wrong count for " + root.label, allExpectedCounts.get(root.label), (int) root.value); - assertEquals("invalid residue", 0, (int) root.residue); for (FacetResultNode child : root.subResults) { assertEquals("wrong count for " + child.label, allExpectedCounts.get(child.label), (int) child.value); } @@ -410,7 +376,6 @@ public class CountingFacetsCollectorTest extends LuceneTestCase { for (FacetResult res : facetResults) { FacetResultNode root = res.getFacetResultNode(); assertEquals("wrong count for " + root.label, allExpectedCounts.get(root.label), (int) root.value); - assertEquals("invalid residue", 0, (int) root.residue); for (FacetResultNode child : root.subResults) { assertEquals("wrong count for " + child.label, allExpectedCounts.get(child.label), (int) child.value); } @@ -435,7 +400,6 @@ public class CountingFacetsCollectorTest extends LuceneTestCase { for (FacetResult res : facetResults) { FacetResultNode root = res.getFacetResultNode(); assertEquals("wrong count for " + root.label, allExpectedCounts.get(root.label), (int) root.value); - assertEquals("invalid residue", 0, (int) root.residue); for (FacetResultNode child : root.subResults) { assertEquals("wrong count for " + child.label, allExpectedCounts.get(child.label), (int) child.value); } @@ -501,7 +465,6 @@ public class CountingFacetsCollectorTest extends LuceneTestCase { for (FacetResult res : facetResults) { FacetResultNode root = res.getFacetResultNode(); assertEquals("wrong count for " + root.label, expCounts.get(root.label), (int) root.value); - assertEquals("invalid residue", 0, (int) root.residue); for (FacetResultNode child : root.subResults) { assertEquals("wrong count for " + child.label, expCounts.get(child.label), (int) child.value); } diff --git a/lucene/facet/src/test/org/apache/lucene/facet/search/TestTopKInEachNodeResultHandler.java b/lucene/facet/src/test/org/apache/lucene/facet/search/TestTopKInEachNodeResultHandler.java index ce4675147ac..7a3f3af2897 100644 --- a/lucene/facet/src/test/org/apache/lucene/facet/search/TestTopKInEachNodeResultHandler.java +++ b/lucene/facet/src/test/org/apache/lucene/facet/search/TestTopKInEachNodeResultHandler.java @@ -182,39 +182,34 @@ public class TestTopKInEachNodeResultHandler extends LuceneTestCase { assertEquals(9, fr.getNumValidDescendants()); FacetResultNode parentRes = fr.getFacetResultNode(); assertEquals(16.0, parentRes.value, Double.MIN_VALUE); - assertEquals(2.0, parentRes.residue, Double.MIN_VALUE); assertEquals(2, parentRes.subResults.size()); // two nodes sorted by descending values: a/b with 8 and a/c with 6 - // a/b has residue 2 and two children a/b/2 with value 3, and a/b/1 with value 2. - // a/c has residue 0, and one child a/c/1 with value 1. - double [] expectedValues0 = { 8.0, 2.0, 3.0, 0.0, 2.0, 0.0, 6.0, 0.0, 1.0, 0.0 }; + // a/b has two children a/b/2 with value 3, and a/b/1 with value 2. + // a/c has one child a/c/1 with value 1. + double [] expectedValues0 = { 8.0, 3.0, 2.0, 6.0, 1.0 }; int i = 0; for (FacetResultNode node : parentRes.subResults) { assertEquals(expectedValues0[i++], node.value, Double.MIN_VALUE); - assertEquals(expectedValues0[i++], node.residue, Double.MIN_VALUE); for (FacetResultNode node2 : node.subResults) { assertEquals(expectedValues0[i++], node2.value, Double.MIN_VALUE); - assertEquals(expectedValues0[i++], node2.residue, Double.MIN_VALUE); } } // now just change the value of the first child of the root to 5, and then rearrange - // expected are: first a/c of value 6 and residue 0, and one child a/c/1 with value 1 - // then a/b with value 5 and residue 2, and both children: a/b/2 with value 3, and a/b/1 with value 2. + // expected are: first a/c of value 6, and one child a/c/1 with value 1 + // then a/b with value 5, and both children: a/b/2 with value 3, and a/b/1 with value 2. for (FacetResultNode node : parentRes.subResults) { node.value = 5.0; break; } // now rearrange - double [] expectedValues00 = { 6.0, 0.0, 1.0, 0.0, 5.0, 2.0, 3.0, 0.0, 2.0, 0.0 }; + double [] expectedValues00 = { 6.0, 1.0, 5.0, 3.0, 2.0 }; fr = cfra23.createFacetResultsHandler(tr).rearrangeFacetResult(fr); i = 0; for (FacetResultNode node : parentRes.subResults) { assertEquals(expectedValues00[i++], node.value, Double.MIN_VALUE); - assertEquals(expectedValues00[i++], node.residue, Double.MIN_VALUE); for (FacetResultNode node2 : node.subResults) { assertEquals(expectedValues00[i++], node2.value, Double.MIN_VALUE); - assertEquals(expectedValues00[i++], node2.residue, Double.MIN_VALUE); } } @@ -223,18 +218,15 @@ public class TestTopKInEachNodeResultHandler extends LuceneTestCase { assertEquals(9, fr.getNumValidDescendants()); parentRes = fr.getFacetResultNode(); assertEquals(16.0, parentRes.value, Double.MIN_VALUE); - assertEquals(2.0, parentRes.residue, Double.MIN_VALUE); assertEquals(2, parentRes.subResults.size()); // two nodes sorted by descending values: a/b with 8 and a/c with 6 - // a/b has residue 2 and two children a/b/2 with value 3, and a/b/1 with value 2. - // a/c has residue 0, and one child a/c/1 with value 1. + // a/b has two children a/b/2 with value 3, and a/b/1 with value 2. + // a/c has one child a/c/1 with value 1. i = 0; for (FacetResultNode node : parentRes.subResults) { assertEquals(expectedValues0[i++], node.value, Double.MIN_VALUE); - assertEquals(expectedValues0[i++], node.residue, Double.MIN_VALUE); for (FacetResultNode node2 : node.subResults) { assertEquals(expectedValues0[i++], node2.value, Double.MIN_VALUE); - assertEquals(expectedValues0[i++], node2.residue, Double.MIN_VALUE); } } @@ -243,16 +235,13 @@ public class TestTopKInEachNodeResultHandler extends LuceneTestCase { assertEquals(4, fr.getNumValidDescendants(), 4); parentRes = fr.getFacetResultNode(); assertEquals(16.0, parentRes.value, Double.MIN_VALUE); - assertEquals(2.0, parentRes.residue, Double.MIN_VALUE); assertEquals(2, parentRes.subResults.size()); // two nodes sorted by descending values: - // a/b with value 8 and residue 0 (because no children considered), - // and a/c with value 6 and residue 0 (because no children considered) - double [] expectedValues2 = { 8.0, 0.0, 6.0, 0.0 }; + // a/b with value 8 and a/c with value 6 + double [] expectedValues2 = { 8.0, 6.0, 0.0}; i = 0; for (FacetResultNode node : parentRes.subResults) { assertEquals(expectedValues2[i++], node.value, Double.MIN_VALUE); - assertEquals(expectedValues2[i++], node.residue, Double.MIN_VALUE); assertEquals(node.subResults.size(), 0); } @@ -261,13 +250,11 @@ public class TestTopKInEachNodeResultHandler extends LuceneTestCase { assertEquals(4, fr.getNumValidDescendants()); parentRes = fr.getFacetResultNode(); assertEquals(8.0, parentRes.value, Double.MIN_VALUE); - assertEquals(2.0, parentRes.residue, Double.MIN_VALUE); assertEquals(2, parentRes.subResults.size()); double [] expectedValues3 = { 3.0, 2.0 }; i = 0; for (FacetResultNode node : parentRes.subResults) { assertEquals(expectedValues3[i++], node.value, Double.MIN_VALUE); - assertEquals(0.0, node.residue, Double.MIN_VALUE); assertEquals(0, node.subResults.size()); } @@ -276,12 +263,10 @@ public class TestTopKInEachNodeResultHandler extends LuceneTestCase { assertEquals(4, fr.getNumValidDescendants()); parentRes = fr.getFacetResultNode(); assertEquals(8.0, parentRes.value, Double.MIN_VALUE); - assertEquals(2.0, parentRes.residue, Double.MIN_VALUE); assertEquals(2, parentRes.subResults.size()); i = 0; for (FacetResultNode node : parentRes.subResults) { assertEquals(expectedValues3[i++], node.value, Double.MIN_VALUE); - assertEquals(0.0, node.residue, Double.MIN_VALUE); assertEquals(0, node.subResults.size()); } @@ -290,12 +275,10 @@ public class TestTopKInEachNodeResultHandler extends LuceneTestCase { assertEquals(4, fr.getNumValidDescendants()); parentRes = fr.getFacetResultNode(); assertEquals(8.0, parentRes.value, Double.MIN_VALUE); - assertEquals(2.0, parentRes.residue, Double.MIN_VALUE); assertEquals(2, parentRes.subResults.size()); i = 0; for (FacetResultNode node : parentRes.subResults) { assertEquals(expectedValues3[i++], node.value, Double.MIN_VALUE); - assertEquals(0.0, node.residue, Double.MIN_VALUE); assertEquals(0, node.subResults.size()); } @@ -304,7 +287,6 @@ public class TestTopKInEachNodeResultHandler extends LuceneTestCase { assertEquals(0, fr.getNumValidDescendants()); // 0 descendants but rootnode parentRes = fr.getFacetResultNode(); assertEquals(8.0, parentRes.value, Double.MIN_VALUE); - assertEquals(0.0, parentRes.residue, Double.MIN_VALUE); assertEquals(0, parentRes.subResults.size()); hasDoctor |= "Doctor".equals(fr.getFacetRequest().categoryPath.components[0]);