dexlib/src/test/java/TryListBuilderTest.java - platform/external/google-smali - Git at Google

 /*
  * [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.jf.dexlib.CodeItem;
 import org.jf.dexlib.DexFile;
 import org.jf.dexlib.TypeIdItem;
 import org.jf.dexlib.util.Pair;
 import org.jf.dexlib.util.TryListBuilder;
 import org.junit.Assert;
 import org.junit.Test;

 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);

         List<CodeItem.EncodedTypeAddrPair> typeAddrPairs = encodedCatchHandler.getHandlers();

         Assert.assertTrue(typeAddrPairs.size() == handlers.length);

         for (int i=0; i<handlers.length; i++) {
             CodeItem.EncodedTypeAddrPair typeAddrPair = typeAddrPairs.get(i);
             Handler handler = handlers[i];

             Assert.assertTrue(typeAddrPair.getTypeReferenceField().getTypeDescriptor().compareTo(handler.type) == 0);
             Assert.assertTrue(typeAddrPair.getHandlerAddress() == handler.handlerAddress);
         }
     }

     @Test
     public void singleTryTest() {
         TryListBuilder tryListBuilder = new TryListBuilder();

         DexFile dexFile = DexFile.makeBlankDexFile();
         TypeIdItem typeIdItem = new TypeIdItem(dexFile, "Ljava/lang/Exception;");
         tryListBuilder.addHandler(typeIdItem, 2, 5, 100);

         Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> 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});
     }

     @Test
     public void catchAllTest1() {
         //|-----|
         // |---|
         TryListBuilder tryListBuilder = new TryListBuilder();

         DexFile dexFile = DexFile.makeBlankDexFile();

         tryListBuilder.addCatchAllHandler(2, 8, 100);
         tryListBuilder.addCatchAllHandler(4, 6, 101);

         Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> tries = retVal.first;

         Assert.assertTrue(tries.size() == 3);
         checkTry(tries.get(0), 2, 4, 100, new Handler[]{});
         checkTry(tries.get(1), 4, 6, 100, new Handler[]{});
         checkTry(tries.get(2), 6, 8, 100, new Handler[]{});
     }

     @Test
     public void catchAllTest2() {
         // |---|
         //|-----|
         TryListBuilder tryListBuilder = new TryListBuilder();

         DexFile dexFile = DexFile.makeBlankDexFile();

         tryListBuilder.addCatchAllHandler(4, 6, 100);
         tryListBuilder.addCatchAllHandler(2, 8, 101);

         Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
         List<CodeItem.TryItem> tries = retVal.first;

         Assert.assertTrue(tries.size() == 3);
         checkTry(tries.get(0), 2, 4, 101, new Handler[]{});
         checkTry(tries.get(1), 4, 6, 100, new Handler[]{});
         checkTry(tries.get(2), 6, 8, 101, new Handler[]{});
     }


 }
	/*
	* [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.jf.dexlib.CodeItem;
	import org.jf.dexlib.DexFile;
	import org.jf.dexlib.TypeIdItem;
	import org.jf.dexlib.util.Pair;
	import org.jf.dexlib.util.TryListBuilder;
	import org.junit.Assert;
	import org.junit.Test;

	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);

	List<CodeItem.EncodedTypeAddrPair> typeAddrPairs = encodedCatchHandler.getHandlers();

	Assert.assertTrue(typeAddrPairs.size() == handlers.length);

	for (int i=0; i<handlers.length; i++) {
	CodeItem.EncodedTypeAddrPair typeAddrPair = typeAddrPairs.get(i);
	Handler handler = handlers[i];

	Assert.assertTrue(typeAddrPair.getTypeReferenceField().getTypeDescriptor().compareTo(handler.type) == 0);
	Assert.assertTrue(typeAddrPair.getHandlerAddress() == handler.handlerAddress);
	}
	}

	@Test
	public void singleTryTest() {
	TryListBuilder tryListBuilder = new TryListBuilder();

	DexFile dexFile = DexFile.makeBlankDexFile();
	TypeIdItem typeIdItem = new TypeIdItem(dexFile, "Ljava/lang/Exception;");
	tryListBuilder.addHandler(typeIdItem, 2, 5, 100);

	Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> 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});
	}

	@Test
	public void catchAllTest1() {
	//\|-----\|
	// \|---\|
	TryListBuilder tryListBuilder = new TryListBuilder();

	DexFile dexFile = DexFile.makeBlankDexFile();

	tryListBuilder.addCatchAllHandler(2, 8, 100);
	tryListBuilder.addCatchAllHandler(4, 6, 101);

	Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> tries = retVal.first;

	Assert.assertTrue(tries.size() == 3);
	checkTry(tries.get(0), 2, 4, 100, new Handler[]{});
	checkTry(tries.get(1), 4, 6, 100, new Handler[]{});
	checkTry(tries.get(2), 6, 8, 100, new Handler[]{});
	}

	@Test
	public void catchAllTest2() {
	// \|---\|
	//\|-----\|
	TryListBuilder tryListBuilder = new TryListBuilder();

	DexFile dexFile = DexFile.makeBlankDexFile();

	tryListBuilder.addCatchAllHandler(4, 6, 100);
	tryListBuilder.addCatchAllHandler(2, 8, 101);

	Pair<List<CodeItem.TryItem>, List<CodeItem.EncodedCatchHandler>> retVal = tryListBuilder.encodeTries(dexFile);
	List<CodeItem.TryItem> tries = retVal.first;

	Assert.assertTrue(tries.size() == 3);
	checkTry(tries.get(0), 2, 4, 101, new Handler[]{});
	checkTry(tries.get(1), 4, 6, 100, new Handler[]{});
	checkTry(tries.get(2), 6, 8, 101, new Handler[]{});
	}



	}