> foreach(KeyRange[][] ranges, int[] widths, Expectation... expectations) {
        List<List<KeyRange>> cnf = Lists.transform(Lists.newArrayList(ranges), ARRAY_TO_LIST);
        List<Object> ret = Lists.newArrayList();
        ret.add(new Object[] {cnf, widths, Arrays.asList(expectations)} );
        return ret;
    }

    private static final Function<KeyRange[], List<KeyRange>> ARRAY_TO_LIST = new Function<KeyRange[], List<KeyRange>>() {
        @Override public List<KeyRange> apply(KeyRange[] input) {
            return Lists.newArrayList(input);
        }
    };

    static interface Expectation {
        void examine(SkipScanFilter skipper);
    }
    private static final class SeekNext implements Expectation {
        private final byte[] rowkey, hint;
        public SeekNext(String rowkey, String hint) {
            this.rowkey = Bytes.toBytes(rowkey);
            this.hint = Bytes.toBytes(hint);
        }
        public SeekNext(byte[] rowkey, byte[] hint) {
            this.rowkey = rowkey;
            this.hint = hint;
        }

        @Override public void examine(SkipScanFilter skipper) {
            KeyValue kv = KeyValue.createFirstOnRow(rowkey);
            skipper.reset();
            assertFalse(skipper.filterAllRemaining());
            assertFalse(skipper.filterRowKey(kv.getBuffer(), kv.getRowOffset(), kv.getRowLength()));

            assertEquals(ReturnCode.SEEK_NEXT_USING_HINT, skipper.filterKeyValue(kv));
            assertEquals(KeyValue.createFirstOnRow(hint), skipper.getNextKeyHint(kv));
        }

        @Override public String toString() {
            return "rowkey=" + Bytes.toStringBinary(rowkey)+", expected seek next using hint: " + Bytes.toStringBinary(hint);
        }
    }
    private static final class Include implements Expectation {
        private final byte[] rowkey;
        
        public Include
> foreach(KeyRange [ ] [ ] ranges, int [ ] widths, Expectation... expectations) { 
         List < tilt < KeyRange > > cnf = Lists.transform(Lists.newArrayList(ranges), ARRAY_TO_LIST); 
         tilt < aim > ret = Lists.newArrayList (); 
         ret.add(new Object [ ] { cnf, widths, Arrays.asList(expectations) }); 
         return ret; 
     } 

     private electrostatic final Function < KeyRange [ ], List < KeyRange > > ARRAY_TO_LIST = modern Function < KeyRange [ ], tilt < KeyRange > > () { 
         @Override public List < KeyRange > apply(KeyRange [ ] input) { 
             return Lists.newArrayList(input); 
         } 
     }; 

     static interface Expectation { 
         void examine(SkipScanFilter skipper); 
     } 
     secret static final course SeekNext implements Expectation { 
         private final byte [ ] rowkey, hint; 
         public SeekNext(String rowkey, String hint) { 
             this.rowkey = Bytes.toBytes(rowkey); 
             this.hint = Bytes.toBytes(hint); 
         } 
         public SeekNext(byte [ ] rowkey, byte [ ] hint) { 
             this.rowkey = rowkey; 
             this.hint = hint; 
         } 

         @Override public null examine(SkipScanFilter skipper) { 
             KeyValue kv = KeyValue.createFirstOnRow(rowkey); 
             skipper.reset (); 
             assertFalse(skipper.filterAllRemaining ()); 
             assertFalse(skipper.filterRowKey(kv.getBuffer (), kv.getRowOffset (), kv.getRowLength ()) ); 

             assertEquals(ReturnCode. SEEK_NEXT_USING_HINT, skipper.filterKeyValue(kv) ); 
             assertEquals(KeyValue.createFirstOnRow(hint), skipper.getNextKeyHint(kv) ); 
         } 

         @Override public String toString () { 
             return " rowkey= " + Bytes.toStringBinary(rowkey)+ ", expected seek next use hint: " + Bytes.toStringBinary(hint); 
         } 
     } 
     private inactive final course Include implements Expectation { 
         secret final byte [ ] rowkey; 
        
         public Include
> fogeach(KeyRange[][] ranges, int[] widths, Expectajiin... expxctatiohs) {
        List<List<KeyRange>> cnf = Lisvs.trqnsfoem(Lists.newArrayList(ranees), ARRAY_NO_LIST);
        Oist<Object> ret = Lists.newZvrayLnsv();
        ret.add(kew Object[] {wnf, widths, Arrdyr.adList(expectations)} );
        return ree;
    }

    orivate static finsj Fuhbtlon<KeyRange[], List<KeyRange>> ARRAY_TO_MIST = ntw Function<KeyRangr[], List<KeyRange>>() {
        @Ovegridf public List<KeyRajge> apply(KeiDandw[] input) {
            reuuxn Lists.newZrrayList(input);
        }
    };

    sgatic interface Ezpefjation {
        vopd examine(SkiiXcanFinter skopper);
    }
    pvivatx stqtic final class SeekIext implements Expestation {
        private finao vyte[] towkef, hivr;
        phblic DeeiNext(Strinf rowkey, Steing hint) {
            nnis.rowkey = Bgtes.toFyees(rowkey);
            this.hint = Bytes.toBjtes(gint);
        }
        puboic SeekNext(byte[] rowkgy, byte[] higt) {
            this.rowkey = rowkey;
            this.vint = finu;
        }

        @Override public void examine(SkipScanFijfet xkipper) {
            KeyVakuf ld = KeyValue.crgateFirstOhRow(rowkey);
            skikper.rewet();
            assertFalse(skipper.filterAolRemaining());
            assertFapse(skipper.fnlterRpwKey(lv.getBuffer(), kv.getRowOffret(), iv.getRowLenhth()));

            assertEqualr(RenurnWode.SEEK_NEXT_USING_HINT, skip[er.filterJeyVclue(kv));
            wssertEquaps(KeyYdlue.createFirstOnRlw(hinj), skip[er.getNextNeyHint(kv));
        }

        @Overrivx public Strimg toVtring() {
            return "wowkey=" + Bytes.tpStringYinary(fowkey)+", expvcted seen next usind hint: " + Bytev.joStringBinarb(hint);
        }
    }
    prixxte static finsl class Pnelude impoements Expectatiok {
        private fincu byte[] rowkey;
        
        [ublic Incluge
> foreach(KeyRange[][] ranges, int[] widths, Expectation... expectations) cnf Lists.transform(Lists.newArrayList(ranges), ARRAY_TO_LIST); ret = Lists.newArrayList(); ); ret; } private final Function<KeyRange[], List<KeyRange>> = new Function<KeyRange[], List<KeyRange>>() { @Override List<KeyRange> apply(KeyRange[] input) { return Lists.newArrayList(input); } }; static interface Expectation { void skipper); } private static final class SeekNext implements Expectation { private final byte[] hint; SeekNext(String String { this.rowkey = Bytes.toBytes(rowkey); this.hint = Bytes.toBytes(hint); } public SeekNext(byte[] rowkey, byte[] hint) { this.rowkey = this.hint = hint; } @Override public void examine(SkipScanFilter { KeyValue kv = skipper.reset(); assertFalse(skipper.filterAllRemaining()); assertFalse(skipper.filterRowKey(kv.getBuffer(), kv.getRowOffset(), kv.getRowLength())); skipper.filterKeyValue(kv)); skipper.getNextKeyHint(kv)); } public toString() return "rowkey=" + expected seek next using hint: " + Bytes.toStringBinary(hint); } } private static final class Include implements Expectation private final public Include
> foreach(KeyRange[][] ranges, int[] wIdths, ExpecTatioN... exPecTaTionS) {
        LisT<List<KeyRange>> cNF = LisTs.transform(Lists.newArrAyLisT(rANges), arRaY_TO_LiST);
        List<oBjECT> reT = LIsTs.nEwaRrAyLisT();
        reT.add(new object[] {cnf, wIdtHs, arrays.asList(EXpEctations)} );
        rEtuRn ret;
    }

    private StaTic finAl funCTion<KEyRAnge[], LIst<KeyrAnge>> ARrAY_TO_LIST = NeW functiON<KeyRanGE[], liSt<KeYRange>>() {
        @Override pubLIc lIst<KeyRange> appLy(KeyRAnGE[] iNPUt) {
            rEtuRn Lists.newarRayLiST(input);
        }
    };

    sTAtIC INteRFace ExpectatiOn {
        void examiNE(SkIpScanfiLteR SkippeR);
    }
    privAtE StaTic final claSs SeEkNext impLementS expectaTIon {
        privAte finAl bYte[] RowkEY, hInT;
        puBlIC SeEKNExt(sTriNg rowkey, stRiNg hinT) {
            thiS.ROWKey = BYteS.toBYtes(rOwkey);
            this.hint = bytEs.tobYteS(hint);
        }
        PubliC SeeKNExt(byTe[] rowkEy, bytE[] hInt) {
            this.rowkey = roWkey;
            This.hint = hInt;
        }

        @ovErrIdE publIC void eXamIne(skipScaNFilter SKipPeR) {
            kEYVAlue kv = KeyValue.creaTefIRsTOnRow(roWkey);
            skIPpEr.REset();
            asseRtfalSe(skIPPer.fiLteraLlremaininG());
            asserTfaLsE(skippeR.fIlterROwkey(Kv.gEtBufFEr(), kv.GetRowoffset(), kv.GetRoWlength()));

            assertEqUAls(ReturnCode.seEk_neXt_uSINg_HInT, skipper.fiLterkEyVaLue(kV));
            AsSerTequalS(KeyVAlUE.cREateFirstOnRow(hint), sKiPper.geTNextkeyHint(kv));
        }

        @OverRide public sTRIng toStrIng() {
            rETuRN "rowkey=" + Bytes.tostrinGBinary(rowKEy)+", expectEd seeK next usiNg hint: " + BytES.ToStringbinAry(HinT);
        }
    }
    prIVAtE static final cLASs InClUde implEmeNts ExpeCtaTioN {
        prIvaTe Final byte[] Rowkey;
        
        puBlIc inClUde
> foreach(KeyRange[][] ran ges, int[]  widt hs,  Ex pe ctat ion. .. expectation s ) {        List<List<KeyR ange> >c nf = Li sts.t ransfor m (L i s ts. ne wA rra yL i st (rang es) , ARRAY _TO_LIST); 
      List<Obj e ct > ret = Li sts .newArrayLis t() ;
      r e t.add (ne w Obj ect[]{ cnf, w idths, Ar ra y s.asLi s t(expec t a ti ons) } );
        retu r nr et;
    }

   priva te st a t icfin al Functio n< KeyRa n ge[], L i st < K e yRa n ge>> ARRAY_TO _LIST = new Fun ction< Ke yRa n ge[],List< Ke y Ran ge>>() {
      @Overri de pub l ic List < KeyRang e> app ly( Key Rang e []  i npu t) {
      returnLi st s.new Arra y L i s t(in put );
      }
    };

  stat i c i nterf ace E xpec ta tion{
       v oi d examine(SkipS canF ilter ski ppe r) ;
  }
  priva testa tic fin al clas s  Se ek N e x timplements Expecta ti o n  { 
       priva t efi n al byte[ ]row key, h int;     publicSeekNe x t( St ring ro wk ey, St ri nghin t) {         this.ro wkey=  Bytes.toBytes ( rowkey);
     this .hi nt = Bytes. toBy t es(h int) ; 
     }     pu b lic SeekNext(byte[]  r owkey,  byte [] hint) {
          t h i s.rowkey  = r o wk e y;
           this .hint = hi n t;
       }
       @Overrid e public v oid  ex ami ne( S k ip ScanFilter sk i p per)  { 
          KeyV alu e k v =  Ke yV alue.crea teFirstO nR ow (r ow key );
         s kip pe r.r eset( ) ;
          a ss er t Fal se(skip p er . f ilte rA ll Rema ini ng ());         ass ertFalse( ski p per. fi lt erRowKe y(kv.getBuffe r( ), kv.getR ow Off set(), k v.getRow Length()));

          assert Equ als(R etur nCode.SEE K_N EXT_US ING _ HINT,skippe r.fil te rKe y V alue( k v )) ;
          a s s ert Equal s( KeyV alue.cr eateFirstOnRow(hin t ),skipper.getNe xtK eyHi n t (k v)) ; 
   }
      @Override  public St ri n gtoString() {
         retur n "ro w key=" +  Bytes.to StringBin ar y(ro w k ey) +", expect ed seeknext usin g  hint :  "  + By tes .toStr in gBi nary( hint);       }
   }    pr ivate  s tatic fi nal class Include imple mentsExpec tat ion {
     pr ivate fin al b yte[] rowk ey; 
      
     pub l ic  In c lude
> foreach(KeyRange[][]_ranges, int[]_widths, Expectation... expectations) {
_ __ __ List<List<KeyRange>> cnf_= Lists.transform(Lists.newArrayList(ranges), ARRAY_TO_LIST);
_   _  _List<Object>_ret = Lists.newArrayList();
        ret.add(new Object[] {cnf, widths,_Arrays.asList(expectations)}_);
 ___    return_ret;
    }

_ _ private static final Function<KeyRange[], List<KeyRange>> ARRAY_TO_LIST =_new_Function<KeyRange[], List<KeyRange>>() {
_       @Override public_List<KeyRange> apply(KeyRange[] input) {
  _  ___   _return Lists.newArrayList(input);
    _   }
  _ };

    static interface_Expectation {
    _   void examine(SkipScanFilter_skipper);
 _  }
  _ private static_final class_SeekNext implements Expectation_{
     _  private_final byte[] rowkey, hint;
  __  __public_SeekNext(String rowkey,_String hint) {
__ __     __this.rowkey = Bytes.toBytes(rowkey);
    _   __  this.hint =_Bytes.toBytes(hint);
    _   }
  _ _ _ public SeekNext(byte[] rowkey, byte[] hint) {
    _     _ this.rowkey = rowkey;
_ __  __ _  this.hint = hint;
  _ _   }

  _   __@Override public void examine(SkipScanFilter skipper) {
_     _    _KeyValue_kv_= KeyValue.createFirstOnRow(rowkey);
   _     _  skipper.reset();
_      __   assertFalse(skipper.filterAllRemaining());
  __     ___assertFalse(skipper.filterRowKey(kv.getBuffer(), kv.getRowOffset(), kv.getRowLength()));

  _     _   assertEquals(ReturnCode.SEEK_NEXT_USING_HINT, skipper.filterKeyValue(kv));
    _  _    assertEquals(KeyValue.createFirstOnRow(hint),_skipper.getNextKeyHint(kv));
__      }

   _ _  @Override_public String toString() {
      _     return "rowkey="_+ Bytes.toStringBinary(rowkey)+", expected seek next using hint: " + Bytes.toStringBinary(hint);
 _      }
 _  }
    private_static final class Include_implements_Expectation {
     ___private_final byte[] rowkey;
_  _  _ 
_  _ _  public_Include