clutiltestcase.java

测试工具

	}

	public void test2ArgsParse4() {
		final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE_MANY };

		final CLArgsParser parser = new CLArgsParser(new String[] { "-Dval1=-1", "-D", "val2=-2", "--define=val-3=-3",
				"--define", "val4-=-4" }, options);

		assertNull(parser.getErrorString(), parser.getErrorString());

		final List clOptions = parser.getArguments();
		final int size = clOptions.size();

		assertEquals(4, size);
		for (int i = 0; i < size; i++) {
			assertEquals(DEFINE_OPT, ((CLOption) clOptions.get(i)).getDescriptor().getId());
		}

		CLOption option;
		option = (CLOption) clOptions.get(0);
		assertEquals("val1", option.getArgument(0));
		assertEquals("-1", option.getArgument(1));

		option = (CLOption) clOptions.get(1);
		assertEquals("val2", option.getArgument(0));
		assertEquals("-2", option.getArgument(1));

		option = (CLOption) clOptions.get(2);
		assertEquals("val-3", option.getArgument(0));
		assertEquals("-3", option.getArgument(1));

		option = (CLOption) clOptions.get(3);
		assertEquals("val4-", option.getArgument(0));
		assertEquals("-4", option.getArgument(1));
	}

	public void testPartParse() {
		final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU };

		final ParserControl control = new AbstractParserControl() {
			public boolean isFinished(int lastOptionCode) {
				return (lastOptionCode == YOU_OPT);
			}
		};

		final CLArgsParser parser = new CLArgsParser(ARGLIST1, options, control);

		assertNull(parser.getErrorString(), parser.getErrorString());

		final List clOptions = parser.getArguments();
		final int size = clOptions.size();

		assertEquals(size, 1);
		assertEquals(((CLOption) clOptions.get(0)).getDescriptor().getId(), YOU_OPT);
	}

	public void test2PartParse() {
		final CLOptionDescriptor[] options1 = new CLOptionDescriptor[] { YOU };

		final CLOptionDescriptor[] options2 = new CLOptionDescriptor[] { ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };

		final ParserControl control1 = new AbstractParserControl() {
			public boolean isFinished(int lastOptionCode) {
				return (lastOptionCode == YOU_OPT);
			}
		};

		final CLArgsParser parser1 = new CLArgsParser(ARGLIST1, options1, control1);

		assertNull(parser1.getErrorString(), parser1.getErrorString());

		final List clOptions1 = parser1.getArguments();
		final int size1 = clOptions1.size();

		assertEquals(size1, 1);
		assertEquals(((CLOption) clOptions1.get(0)).getDescriptor().getId(), YOU_OPT);

		final CLArgsParser parser2 = new CLArgsParser(parser1.getUnparsedArgs(), options2);

		assertNull(parser2.getErrorString(), parser2.getErrorString());

		final List clOptions2 = parser2.getArguments();
		final int size2 = clOptions2.size();

		assertEquals(size2, 7);
		assertEquals(((CLOption) clOptions2.get(0)).getDescriptor().getId(), 0);
		assertEquals(((CLOption) clOptions2.get(1)).getDescriptor().getId(), ALL_OPT);
		assertEquals(((CLOption) clOptions2.get(2)).getDescriptor().getId(), CLEAR1_OPT);
		assertEquals(((CLOption) clOptions2.get(3)).getDescriptor().getId(), CLEAR2_OPT);
		assertEquals(((CLOption) clOptions2.get(4)).getDescriptor().getId(), CLEAR3_OPT);
		assertEquals(((CLOption) clOptions2.get(5)).getDescriptor().getId(), CLEAR5_OPT);
		assertEquals(((CLOption) clOptions2.get(6)).getDescriptor().getId(), 0);
	}

	public void test2PartPartialParse() {
		final CLOptionDescriptor[] options1 = new CLOptionDescriptor[] { YOU, ALL, CLEAR1 };

		final CLOptionDescriptor[] options2 = new CLOptionDescriptor[] {};

		final ParserControl control1 = new AbstractParserControl() {
			public boolean isFinished(final int lastOptionCode) {
				return (lastOptionCode == CLEAR1_OPT);
			}
		};

		final CLArgsParser parser1 = new CLArgsParser(ARGLIST1, options1, control1);

		assertNull(parser1.getErrorString(), parser1.getErrorString());

		final List clOptions1 = parser1.getArguments();
		final int size1 = clOptions1.size();

		assertEquals(size1, 4);
		assertEquals(((CLOption) clOptions1.get(0)).getDescriptor().getId(), YOU_OPT);
		assertEquals(((CLOption) clOptions1.get(1)).getDescriptor().getId(), 0);
		assertEquals(((CLOption) clOptions1.get(2)).getDescriptor().getId(), ALL_OPT);
		assertEquals(((CLOption) clOptions1.get(3)).getDescriptor().getId(), CLEAR1_OPT);

		assertTrue(parser1.getUnparsedArgs()[0].equals("ler"));

		final CLArgsParser parser2 = new CLArgsParser(parser1.getUnparsedArgs(), options2);

		assertNull(parser2.getErrorString(), parser2.getErrorString());

		final List clOptions2 = parser2.getArguments();
		final int size2 = clOptions2.size();

		assertEquals(size2, 2);
		assertEquals(((CLOption) clOptions2.get(0)).getDescriptor().getId(), 0);
		assertEquals(((CLOption) clOptions2.get(1)).getDescriptor().getId(), 0);
	}

	public void testDuplicatesFail() {
		final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU, ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };

		final CLArgsParser parser = new CLArgsParser(ARGLIST1, options);

		assertNull(parser.getErrorString(), parser.getErrorString());
	}

	public void testIncomplete2Args() {
		// "-Dstupid="
		final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE };

		final CLArgsParser parser = new CLArgsParser(new String[] { "-Dstupid=" }, options);

		assertNull(parser.getErrorString(), parser.getErrorString());

		final List clOptions = parser.getArguments();
		final int size = clOptions.size();

		assertEquals(size, 1);
		final CLOption option = (CLOption) clOptions.get(0);
		assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
		assertEquals(option.getArgument(0), "stupid");
		assertEquals(option.getArgument(1), "");
	}

	public void testIncomplete2ArgsMixed() {
		// "-Dstupid=","-c"
		final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, CLEAR1 };

		final String[] args = new String[] { "-Dstupid=", "-c" };

		final CLArgsParser parser = new CLArgsParser(args, options);

		assertNull(parser.getErrorString(), parser.getErrorString());

		final List clOptions = parser.getArguments();
		final int size = clOptions.size();

		assertEquals(size, 2);
		assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), CLEAR1_OPT);
		final CLOption option = (CLOption) clOptions.get(0);
		assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
		assertEquals(option.getArgument(0), "stupid");
		assertEquals(option.getArgument(1), "");
	}

	public void testIncomplete2ArgsMixedNoEq() {
		// "-Dstupid","-c"
		final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, CLEAR1 };

		final String[] args = new String[] { "-DStupid", "-c" };

		final CLArgsParser parser = new CLArgsParser(args, options);

		assertNull(parser.getErrorString(), parser.getErrorString());

		final List clOptions = parser.getArguments();
		final int size = clOptions.size();

		assertEquals(size, 2);
		assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), CLEAR1_OPT);
		final CLOption option = (CLOption) clOptions.get(0);
		assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
		assertEquals(option.getArgument(0), "Stupid");
		assertEquals(option.getArgument(1), "");
	}

	/**
	 * Test the getArgumentById and getArgumentByName lookup methods.
	 */
	public void testArgumentLookup() {
		final String[] args = { "-f", "testarg" };
		final CLOptionDescriptor[] options = { FILE };
		final CLArgsParser parser = new CLArgsParser(args, options);

		assertNull(parser.getErrorString(), parser.getErrorString());

		CLOption optionById = parser.getArgumentById(FILE_OPT);
		assertNotNull(optionById);
		assertEquals(FILE_OPT, optionById.getDescriptor().getId());
		assertEquals("testarg", optionById.getArgument());

		CLOption optionByName = parser.getArgumentByName(FILE.getName());
		assertNotNull(optionByName);
		assertEquals(FILE_OPT, optionByName.getDescriptor().getId());
		assertEquals("testarg", optionByName.getArgument());
	}

	/**
	 * Test that you can have null long forms.
	 */
	public void testNullLongForm() {
		final CLOptionDescriptor test = new CLOptionDescriptor(null, CLOptionDescriptor.ARGUMENT_DISALLOWED, 'n',
				"test null long form");

		final String[] args = { "-n", "testarg" };
		final CLOptionDescriptor[] options = { test };
		final CLArgsParser parser = new CLArgsParser(args, options);

		assertNull(parser.getErrorString(), parser.getErrorString());

		final CLOption optionByID = parser.getArgumentById('n');
		assertNotNull(optionByID);
		assertEquals('n', optionByID.getDescriptor().getId());

		final CLOption optionByName = parser.getArgumentByName(FILE.getName());
		assertNull("Looking for non-existent option by name", optionByName);
	}

	/**
	 * Test that you can have null descriptions.
	 */
	public void testNullDescription() {
		final CLOptionDescriptor test = new CLOptionDescriptor("nulltest", CLOptionDescriptor.ARGUMENT_DISALLOWED, 'n',
				null);

		final String[] args = { "-n", "testarg" };
		final CLOptionDescriptor[] options = { test };
		final CLArgsParser parser = new CLArgsParser(args, options);

		assertNull(parser.getErrorString(), parser.getErrorString());

		final CLOption optionByID = parser.getArgumentById('n');
		assertNotNull(optionByID);
		assertEquals('n', optionByID.getDescriptor().getId());

		final StringBuffer sb = CLUtil.describeOptions(options);
		final String lineSeparator = System.getProperty("line.separator");
		assertEquals("Testing display of null description", "\t-n, --nulltest" + lineSeparator, sb.toString());
	}
	
	public void testCombinations() throws Exception {
		check(new String [] {},"");	
		check(new String [] {"--none",
				             "-0"
				             },
				             "-0 -0"); // Canonical form
		check(new String [] {"--one=a",
				             "--one","A",
				             "-1b",
				             "-1=c",
				             "-1","d"
				             },
		                     "-1=[a] -1=[A] -1=[b] -1=[c] -1=[d]");	
		check(new String [] {"-2n=v",
				             "-2","N=V"
				             },
				             "-2=[n, v] -2=[N, V]");	
		check(new String [] {"--two=n=v",
				             "--two","N=V"
				             },
				             "-2=[n, v] -2=[N, V]");
		// Test optional arguments
		check(new String [] {"-?",
				             "A", // Separate argument
				             "-?=B",
				             "-?C",
				             "-?"
				            },
	                         "-? [A] -?=[B] -?=[C] -?");	
		check(new String [] {"--optional=A", // OK
	                         "--optional","B", // should treat B as separate
	                         "--optional" // Should have no arg
	                         },
	                         "-?=[A] -? [B] -?");	
	}
	
	private void check(String args[], String canon){
		final CLArgsParser parser = new CLArgsParser(args, OPTIONS);

		assertNull(parser.getErrorString(),parser.getErrorString());

		final List clOptions = parser.getArguments();
		final int size = clOptions.size();
		StringBuffer sb = new StringBuffer();
		for (int i=0; i< size; i++){
			if (i>0) sb.append(" ");
			sb.append(((CLOption)clOptions.get(i)).toShortString());	
		}
		assertEquals("Canonical form ("+size+")",canon,sb.toString());
	}
	/*
	 * TODO add tests to check for: - name clash - long option abbreviations
	 * (match shortest unique abbreviation)
	 */

}