From a77aba807f0d43ff14cc40bf7144c45638dcc89a Mon Sep 17 00:00:00 2001 From: "JesusFreke@JesusFreke.com" Date: Sat, 16 May 2009 06:39:25 +0000 Subject: [PATCH] Added tests for TryListBuilder and fixed several bugs in TryListBuilder git-svn-id: https://smali.googlecode.com/svn/trunk@39 55b6fa8a-2a1e-11de-a435-ffa8d773f76a --- .../java/org/JesusFreke/dexlib/CodeItem.java | 51 ++- .../dexlib/util/TryListBuilder.java | 44 +- src/test/java/TryListBuilderTest.java | 430 ++++++++++++++++++ 3 files changed, 504 insertions(+), 21 deletions(-) create mode 100644 src/test/java/TryListBuilderTest.java diff --git a/src/main/java/org/JesusFreke/dexlib/CodeItem.java b/src/main/java/org/JesusFreke/dexlib/CodeItem.java index f6714641..cbd3c2e2 100644 --- a/src/main/java/org/JesusFreke/dexlib/CodeItem.java +++ b/src/main/java/org/JesusFreke/dexlib/CodeItem.java @@ -166,6 +166,18 @@ public class CodeItem extends OffsettedItem { protected Field[] getFields() { return fields; } + + public int getStartAddress() { + return startAddr.getCachedValue(); + } + + public int getEndAddress() { + return startAddr.getCachedValue() + insnCount.getCachedValue(); + } + + public EncodedCatchHandler getHandler() { + return encodedCatchHandlerReference.getReference(); + } } public static class EncodedCatchHandlerReference extends ShortIntegerField { @@ -189,6 +201,10 @@ public class CodeItem extends OffsettedItem { this.encodedCatchHandler = encodedCatchHandler; } + public EncodedCatchHandler getReference() { + return encodedCatchHandler; + } + public void copyTo(DexFile dexFile, CachedIntegerValueField _copy) { EncodedCatchHandlerReference copy = (EncodedCatchHandlerReference)_copy; @@ -393,28 +409,55 @@ public class CodeItem extends OffsettedItem { this.offset = offset; return super.place(offset); } + + public int getCatchAllAddress() { + if (hasCatchAll) { + return catchAllAddress.getCachedValue(); + } else { + return -1; + } + } + + public int getHandlerCount() { + return list.size(); + } + + public EncodedTypeAddrPair getHandler(int index) { + return list.get(index); + } } public static class EncodedTypeAddrPair extends CompositeField { public final Field[] fields; + public final IndexedItemReference type; + public final Leb128Field handlerAddress; + public EncodedTypeAddrPair(DexFile dexFile) { fields = new Field[] { - new IndexedItemReference(dexFile.TypeIdsSection, new Leb128Field()), - new Leb128Field() + type = new IndexedItemReference(dexFile.TypeIdsSection, new Leb128Field()), + handlerAddress = new Leb128Field() }; } public EncodedTypeAddrPair(DexFile dexFile, TypeIdItem type, int handlerOffset) { fields = new Field[] { - new IndexedItemReference(dexFile, type, new Leb128Field()), - new Leb128Field(handlerOffset) + this.type = new IndexedItemReference(dexFile, type, new Leb128Field()), + this.handlerAddress = new Leb128Field(handlerOffset) }; } protected Field[] getFields() { return fields; } + + public TypeIdItem getType() { + return type.getReference(); + } + + public int getHandlerAddress() { + return handlerAddress.getCachedValue(); + } } private class InstructionListField implements Field { diff --git a/src/main/java/org/JesusFreke/dexlib/util/TryListBuilder.java b/src/main/java/org/JesusFreke/dexlib/util/TryListBuilder.java index b8442994..3f4c411a 100644 --- a/src/main/java/org/JesusFreke/dexlib/util/TryListBuilder.java +++ b/src/main/java/org/JesusFreke/dexlib/util/TryListBuilder.java @@ -100,6 +100,7 @@ public class TryListBuilder TryRange tryRange = new TryRange(address, endAddress); tryRange.catchAllHandlerAddress = this.catchAllHandlerAddress; + tryRange.handlers.addAll(this.handlers); append(tryRange); this.endAddress = address; @@ -127,10 +128,6 @@ public class TryListBuilder } } - /*public TryListBuilder(CodeItem item) - { - } */ - public Pair, List> encodeTries(DexFile dexFile) { if (firstTryRange.next == lastTryRange) { return new Pair, List>(null, null); @@ -217,13 +214,13 @@ public class TryListBuilder TryRange tryRange = firstTryRange.next; while (tryRange != lastTryRange) { - if (tryRange.startAddress == startAddress) { + if (startAddress == tryRange.startAddress) { //|-----| //^------ /*Bam. We hit the start of the range right on the head*/ startRange = tryRange; break; - } else if (tryRange.startAddress < startAddress && tryRange.endAddress > startAddress) { + } else if (startAddress > tryRange.startAddress && startAddress < tryRange.endAddress) { //|-----| // ^---- /*Almost. The start of the range being added is in the middle @@ -231,14 +228,25 @@ public class TryListBuilder at the start address of the range being added*/ startRange = tryRange.split(startAddress); break; - }else if (tryRange.startAddress > startAddress) { - // |-----| - //^--------- - /*Oops, too far! We've passed the start of the range being added. - We need to add a new range just before this one*/ - startRange = new TryRange(startAddress, tryRange.startAddress); - tryRange.prepend(startRange); - break; + }else if (startAddress < tryRange.startAddress) { + if (endAddress <= tryRange.startAddress) { + // |-----| + //^--^ + /*Oops, totally too far! The new range doesn't overlap any existing + ones, so we just add it and return*/ + startRange = new TryRange(startAddress, endAddress); + tryRange.prepend(startRange); + return new Pair(startRange, startRange); + } else { + // |-----| + //^--------- + /*Oops, too far! We've passed the start of the range being added, but + the new range does overlap this one. We need to add a new range just + before this one*/ + startRange = new TryRange(startAddress, tryRange.startAddress); + tryRange.prepend(startRange); + break; + } } tryRange = tryRange.next; @@ -250,9 +258,9 @@ public class TryListBuilder end before the range being added starts. In either case, we just need to add a new range at the end of the list*/ if (startRange == null) { - TryRange newRange = new TryRange(startAddress, endAddress); - lastTryRange.prepend(newRange); - return new Pair(newRange, newRange); + startRange = new TryRange(startAddress, endAddress); + lastTryRange.prepend(startRange); + return new Pair(startRange, startRange); } tryRange = startRange; @@ -302,6 +310,8 @@ public class TryListBuilder TryRange startRange = null; TryRange endRange = null; + //TODO: need to check for pre-existing exception types in the handler list? + Pair ranges = getBoundingRanges(startAddress, endAddress); startRange = ranges.first; endRange = ranges.second; diff --git a/src/test/java/TryListBuilderTest.java b/src/test/java/TryListBuilderTest.java new file mode 100644 index 00000000..08a65d35 --- /dev/null +++ b/src/test/java/TryListBuilderTest.java @@ -0,0 +1,430 @@ +/* + * [The "BSD licence"] + * Copyright (c) 2009 Ben Gruver + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +import org.JesusFreke.dexlib.util.TryListBuilder; +import org.JesusFreke.dexlib.util.Pair; +import org.JesusFreke.dexlib.TypeIdItem; +import org.JesusFreke.dexlib.DexFile; +import org.JesusFreke.dexlib.CodeItem; +import org.junit.*; + +import java.util.List; + + +public class TryListBuilderTest +{ + + private static class Handler + { + public String type; + public int handlerAddress; + + public Handler(String type, int handlerAddress) { + this.type = type; + this.handlerAddress = handlerAddress; + } + } + + public static void checkTry(CodeItem.TryItem tryItem, + int startAddress, + int endAddress, + int catchAllAddress, + Handler[] handlers) { + + Assert.assertTrue(tryItem.getStartAddress() == startAddress); + Assert.assertTrue(tryItem.getEndAddress() == endAddress); + + CodeItem.EncodedCatchHandler encodedCatchHandler = tryItem.getHandler(); + + Assert.assertTrue(encodedCatchHandler.getCatchAllAddress() == catchAllAddress); + + Assert.assertTrue(encodedCatchHandler.getHandlerCount() == handlers.length); + + for (int i=0; i, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 1); + checkTry(tries.get(0), 2, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 100)}); + } + + + @Test + public void singleTryWithCatchAllTest() { + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem = new TypeIdItem(dexFile, "Ljava/lang/Exception;"); + tryListBuilder.addHandler(typeIdItem, 2, 5, 100); + + tryListBuilder.addCatchAllHandler(2, 5, 101); + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 1); + checkTry(tries.get(0), 2, 5, 101, new Handler[]{new Handler("Ljava/lang/Exception;", 100)}); + } + + @Test + public void twoTriesTest1() { + //|-----| + // |-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem = new TypeIdItem(dexFile, "Ljava/lang/Exception;"); + tryListBuilder.addHandler(typeIdItem, 2, 5, 100); + + tryListBuilder.addHandler(typeIdItem, 5, 10, 101); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 100)}); + checkTry(tries.get(1), 5, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 101)}); + } + + @Test + public void twoTriesTest2() { + //|-----| + // |-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem = new TypeIdItem(dexFile, "Ljava/lang/Exception;"); + tryListBuilder.addHandler(typeIdItem, 2, 5, 100); + + tryListBuilder.addHandler(typeIdItem, 10, 15, 101); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 100)}); + checkTry(tries.get(1), 10, 15, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 101)}); + } + + @Test + public void twoTriesTest3() { + // |-----| + //|-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem = new TypeIdItem(dexFile, "Ljava/lang/Exception;"); + tryListBuilder.addHandler(typeIdItem, 5, 10, 101); + tryListBuilder.addHandler(typeIdItem, 2, 5, 100); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 100)}); + checkTry(tries.get(1), 5, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 101)}); + } + + @Test + public void twoTriesTest4() { + // |-----| + //|-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem = new TypeIdItem(dexFile, "Ljava/lang/Exception;"); + + tryListBuilder.addHandler(typeIdItem, 10, 15, 101); + + tryListBuilder.addHandler(typeIdItem, 2, 5, 100); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 100)}); + checkTry(tries.get(1), 10, 15, -1, new Handler[]{new Handler("Ljava/lang/Exception;", 101)}); + } + + @Test + public void twoTriesTest5() { + //|-----| + //|-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem1, 2, 5, 100); + tryListBuilder.addHandler(typeIdItem2, 2, 5, 101); + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 1); + checkTry(tries.get(0), 2, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100), new Handler("Ljava/lang/Exception2;", 101)}); + } + + @Test + public void twoTriesTest6() { + //|-----| + // |-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem1, 2, 5, 100); + tryListBuilder.addHandler(typeIdItem2, 4, 10, 101); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 3); + checkTry(tries.get(0), 2, 4, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(1), 4, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100), new Handler("Ljava/lang/Exception2;", 101)}); + checkTry(tries.get(2), 5, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception2;", 101)}); + } + + + @Test + public void twoTriesTest7() { + // |-----| + //|-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem2, 4, 10, 101); + tryListBuilder.addHandler(typeIdItem1, 2, 5, 100); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 3); + checkTry(tries.get(0), 2, 4, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(1), 4, 5, -1, new Handler[]{new Handler("Ljava/lang/Exception2;", 101), new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(2), 5, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception2;", 101)}); + } + + @Test + public void twoTriesTest8() { + //|-----| + // |---| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem1, 2, 10, 100); + tryListBuilder.addHandler(typeIdItem2, 4, 6, 101); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 3); + checkTry(tries.get(0), 2, 4, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(1), 4, 6, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100), new Handler("Ljava/lang/Exception2;", 101)}); + checkTry(tries.get(2), 6, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + } + + @Test + public void twoTriesTest9() { + // |---| + //|-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem2, 4, 6, 101); + tryListBuilder.addHandler(typeIdItem1, 2, 10, 100); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 3); + checkTry(tries.get(0), 2, 4, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(1), 4, 6, -1, new Handler[]{new Handler("Ljava/lang/Exception2;", 101), new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(2), 6, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + } + + @Test + public void twoTriesTest10() { + //|-----| + //|---| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem1, 2, 10, 100); + tryListBuilder.addHandler(typeIdItem2, 2, 6, 101); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 6, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100), new Handler("Ljava/lang/Exception2;", 101)}); + checkTry(tries.get(1), 6, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + } + + @Test + public void twoTriesTest11() { + //|---| + //|-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem2, 2, 6, 101); + tryListBuilder.addHandler(typeIdItem1, 2, 10, 100); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 6, -1, new Handler[]{new Handler("Ljava/lang/Exception2;", 101), new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(1), 6, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + } + + @Test + public void twoTriesTest12() { + //|-----| + // |---| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem1, 2, 10, 100); + tryListBuilder.addHandler(typeIdItem2, 6, 10, 101); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 6, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(1), 6, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100), new Handler("Ljava/lang/Exception2;", 101)}); + } + + @Test + public void twoTriesTest13() { + // |---| + //|-----| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + + tryListBuilder.addHandler(typeIdItem2, 6, 10, 101); + tryListBuilder.addHandler(typeIdItem1, 2, 10, 100); + + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Assert.assertTrue(tries.size() == 2); + checkTry(tries.get(0), 2, 6, -1, new Handler[]{new Handler("Ljava/lang/Exception1;", 100)}); + checkTry(tries.get(1), 6, 10, -1, new Handler[]{new Handler("Ljava/lang/Exception2;", 101), new Handler("Ljava/lang/Exception1;", 100)}); + } + + + @Test + public void threeTriesTest1() { + // |-----| + // |-----| + //|--------------------| + TryListBuilder tryListBuilder = new TryListBuilder(); + + DexFile dexFile = DexFile.makeBlankDexFile(); + TypeIdItem typeIdItem1 = new TypeIdItem(dexFile, "Ljava/lang/Exception1;"); + TypeIdItem typeIdItem2 = new TypeIdItem(dexFile, "Ljava/lang/Exception2;"); + TypeIdItem typeIdItem3= new TypeIdItem(dexFile, "Ljava/lang/Exception3;"); + + tryListBuilder.addHandler(typeIdItem1, 2, 4, 100); + tryListBuilder.addHandler(typeIdItem2, 6, 10, 101); + tryListBuilder.addHandler(typeIdItem3, 0, 12, 102); + + Pair, List> retVal = tryListBuilder.encodeTries(dexFile); + List tries = retVal.first; + + Handler handler1 = new Handler("Ljava/lang/Exception1;", 100); + Handler handler2 = new Handler("Ljava/lang/Exception2;", 101); + Handler handler3 = new Handler("Ljava/lang/Exception3;", 102); + + Assert.assertTrue(tries.size() == 5); + checkTry(tries.get(0), 0, 2, -1, new Handler[]{handler3}); + checkTry(tries.get(1), 2, 4, -1, new Handler[]{handler1, handler3}); + checkTry(tries.get(2), 4, 6, -1, new Handler[]{handler3}); + checkTry(tries.get(3), 6, 10, -1, new Handler[]{handler2, handler3}); + checkTry(tries.get(4), 10, 12, -1, new Handler[]{handler3}); + } + + + +}