@Test public void testEmpty() throws RecognitionException, IOException { VM vm = new VM( "ENTRY {title}{}{} READ STRINGS { s } FUNCTION {test} " + "{ s empty$ " + // FALSE "\"\" empty$ " + // FALSE "\" \" empty$ " + // FALSE " title empty$ " + // FALSE " \" HALLO \" empty$ } ITERATE {test} "); Vector<BibtexEntry> v = new Vector<>(); v.add(TestVM.bibtexString2BibtexEntry("@article{a, author=\"AAA\"}")); vm.run(v); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testMissing() throws RecognitionException, IOException { VM vm = new VM( // "ENTRY { title } { } { label } " + // "FUNCTION {presort} { cite$ 'sort.key$ := } " + // "ITERATE {presort} " + // "READ SORT " + // "FUNCTION {test}{ title missing$ cite$ } " + // "ITERATE { test }"); Vector<BibtexEntry> v = new Vector<>(); v.add(t1BibtexEntry()); v.add(TestVM.bibtexString2BibtexEntry("@article{test, author=\"No title\"}")); vm.run(v); Assert.assertEquals(4, vm.getStack().size()); Assert.assertEquals("test", vm.getStack().pop()); Assert.assertEquals(1, vm.getStack().pop()); Assert.assertEquals("canh05", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().pop()); }
@Test public void testIterate() throws RecognitionException, IOException { VM vm = new VM( "" + "ENTRY { " + " address " + " author " + " title " + " type " + "} {} { label } " + "FUNCTION {test}{ cite$ } " + "READ " + "ITERATE { test }"); Vector<BibtexEntry> v = new Vector<>(); v.add(t1BibtexEntry()); v.add(TestVM.bibtexString2BibtexEntry("@article{test, title=\"BLA\"}")); vm.run(v); Assert.assertEquals(2, vm.getStack().size()); String s1 = (String) vm.getStack().pop(); String s2 = (String) vm.getStack().pop(); if (s1.equals("canh05")) { Assert.assertEquals("test", s2); } else { Assert.assertEquals("canh05", s2); Assert.assertEquals("test", s1); } }
@Test public void testFormatName() throws RecognitionException, IOException { { VM vm = new VM( "FUNCTION {format}{ \"Charles Louis Xavier Joseph de la Vall{\\'e}e Poussin\" #1 \"{vv~}{ll}{, jj}{, f}?\" format.name$ }" + "EXECUTE {format}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals("de~la Vall{\\'e}e~Poussin, C.~L. X.~J?", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); } VM vm = new VM( "ENTRY { author } { } { label } " + "FUNCTION {presort} { cite$ 'sort.key$ := } " + "ITERATE { presort } " + "READ " + "SORT " + "FUNCTION {format}{ author #2 \"{vv~}{ll}{, jj}{, f}?\" format.name$ }" + "ITERATE {format}"); Vector<BibtexEntry> v = new Vector<>(); v.add(t1BibtexEntry()); v.add( TestVM.bibtexString2BibtexEntry( "@book{test, author=\"Jonathan Meyer and Charles Louis Xavier Joseph de la Vall{\\'e}e Poussin\"}")); vm.run(v); Assert.assertEquals("de~la Vall{\\'e}e~Poussin, C.~L. X.~J?", vm.getStack().pop()); Assert.assertEquals("Annabi, H?", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVMExecuteSimple2() throws RecognitionException { VM vm = new VM( "FUNCTION {a}{ #5 #5 = " + "#1 #2 = " + "#3 #4 < " + "#4 #3 < " + "#4 #4 < " + "#3 #4 > " + "#4 #3 > " + "#4 #4 > " + "\"H\" \"H\" = " + "\"H\" \"Ha\" = } " + "EXECUTE {a}"); List<BibEntry> v = new ArrayList<>(); vm.run(v); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testChangeCase() throws RecognitionException, IOException { VM vm = new VM( "STRINGS { title } " + "READ " + "FUNCTION {format.title}" + " { duplicate$ empty$ " + " { pop$ \"\" } " + " { \"t\" change.case$ } " + " if$ " + "} " + "FUNCTION {test} {" + " \"hello world\" \"u\" change.case$ format.title " + " \"Hello World\" format.title " + " \"\" format.title " + " \"{A}{D}/{C}ycle: {I}{B}{M}'s {F}ramework for {A}pplication {D}evelopment and {C}ase\" \"u\" change.case$ format.title " + "}" + "EXECUTE {test} "); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals( "{A}{D}/{C}ycle: {I}{B}{M}'s {F}ramework for {A}pplication {D}evelopment and {C}ase", vm.getStack().pop()); Assert.assertEquals("", vm.getStack().pop()); Assert.assertEquals("Hello world", vm.getStack().pop()); Assert.assertEquals("Hello world", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVMChrToIntIntToChr() throws RecognitionException { VM vm = new VM("FUNCTION {test} { \"H\" chr.to.int$ int.to.chr$ }" + "EXECUTE {test}"); List<BibEntry> v = new ArrayList<>(); vm.run(v); Assert.assertEquals("H", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVMIntToStr() throws RecognitionException, IOException { VM vm = new VM("FUNCTION {test} { #3 int.to.str$ #9999 int.to.str$}" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals("9999", vm.getStack().pop()); Assert.assertEquals("3", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testBuildIn() throws RecognitionException, IOException { VM vm = new VM("EXECUTE {global.max$}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(Integer.MAX_VALUE, vm.getStack().pop()); Assert.assertTrue(vm.getStack().empty()); }
@Test public void testVMIfSkipPop() throws RecognitionException, IOException { VM vm = new VM( "FUNCTION {not} { { #0 } { #1 } if$ }" + "FUNCTION {and} { 'skip$ { pop$ #0 } if$ }" + "FUNCTION {or} { { pop$ #1 } 'skip$ if$ }" + "FUNCTION {test} { " + "#1 #1 and #0 #1 and #1 #0 and #0 #0 and " + "#0 not #1 not " + "#1 #1 or #0 #1 or #1 #0 or #0 #0 or }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVMArithmetic() throws RecognitionException { VM vm = new VM("FUNCTION {test} { " + "#1 #1 + #5 #2 - }" + "EXECUTE {test}"); List<BibEntry> v = new ArrayList<>(); vm.run(v); Assert.assertEquals(3, vm.getStack().pop()); Assert.assertEquals(2, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testFormatName() throws RecognitionException { VM vm = new VM( "FUNCTION {format}{ \"Charles Louis Xavier Joseph de la Vall{\\'e}e Poussin\" #1 \"{vv~}{ll}{, jj}{, f}?\" format.name$ }" + "EXECUTE {format}"); List<BibEntry> v = new ArrayList<>(); vm.run(v); Assert.assertEquals("de~la Vall{\\'e}e~Poussin, C.~L. X.~J?", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVMSwap() throws RecognitionException, IOException { VM vm = new VM("FUNCTION {a}{ #3 \"Hallo\" swap$ } EXECUTE { a }"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(2, vm.getStack().size()); Assert.assertEquals(3, vm.getStack().pop()); Assert.assertEquals("Hallo", vm.getStack().pop()); }
@Override public void execute(BstEntry context) { Stack<Object> stack = vm.getStack(); if (stack.size() < 3) { throw new VMException("Not enough operands on stack for operation format.name$"); } Object o1 = stack.pop(); Object o2 = stack.pop(); Object o3 = stack.pop(); if (!(o1 instanceof String) && !(o2 instanceof Integer) && !(o3 instanceof String)) { // warning("A string is needed for change.case$"); stack.push(""); return; } String format = (String) o1; Integer name = (Integer) o2; String names = (String) o3; if (names == null) { stack.push(""); } else { AuthorList a = AuthorList.parse(names); if (name > a.getNumberOfAuthors()) { throw new VMException("Author Out of Bounds. Number " + name + " invalid for " + names); } Author author = a.getAuthor(name - 1); stack.push(BibtexNameFormatter.formatName(author, format, vm)); } }
@Test public void testVMChrToInt() throws RecognitionException, IOException { { VM vm = new VM("FUNCTION {test} { \"H\" chr.to.int$ }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(72, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); } VM vm = new VM("FUNCTION {test} { \"H\" chr.to.int$ int.to.chr$ }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals("H", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testNumNames() throws RecognitionException { VM vm = new VM("FUNCTION {test} { \"Johnny Foo and Mary Bar\" num.names$ }" + "EXECUTE {test}"); List<BibEntry> v = new ArrayList<>(); vm.run(v); Assert.assertEquals(2, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVMExecuteSimple() throws RecognitionException, IOException { { VM vm = new VM( "" + "INTEGERS { variable.a } " + "FUNCTION {init.state.consts}{ #5 'variable.a := } " + "EXECUTE {init.state.consts}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(new Integer(5), vm.getIntegers().get("variable.a")); } VM vm = new VM( "FUNCTION {a}{ #5 #5 = " + "#1 #2 = " + "#3 #4 < " + "#4 #3 < " + "#4 #4 < " + "#3 #4 > " + "#4 #3 > " + "#4 #4 > " + "\"H\" \"H\" = " + "\"H\" \"Ha\" = } " + "EXECUTE {a}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(VM.FALSE, vm.getStack().pop()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testNumNames() throws RecognitionException, IOException { { VM vm = new VM("FUNCTION {test} { \"Johnny Foo and Mary Bar\" num.names$ }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(2, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); } VM vm = new VM("FUNCTION {test} { \"Johnny Foo { and } Mary Bar\" num.names$ }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(1, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testQuote() throws RecognitionException, IOException { VM vm = new VM("FUNCTION {a}{ quote$ quote$ * } EXECUTE {a}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals("\"\"", vm.getStack().pop()); }
@Test public void testWhile() throws RecognitionException, IOException { VM vm = new VM( "STRINGS { t } " + "FUNCTION {not} { " + " { #0 } { #1 } if$ } " + "FUNCTION {n.dashify} " + "{ \"HELLO-WORLD\" " + " 't := " + " \"\" " + " { t empty$ not } " + " { t #1 #1 substring$ \"-\" = " + " { t #1 #2 substring$ \"--\" = not " + " { \"--\" * " + " t #2 global.max$ substring$ 't := " + " } " + " { { t #1 #1 substring$ \"-\" = } " + " { \"-\" * " + " t #2 global.max$ substring$ 't := " + " } " + " while$ " + " } " + " if$ " + " } " + " { t #1 #1 substring$ * " + " t #2 global.max$ substring$ 't := " + " } " + " if$ " + " } " + " while$ " + " } " + " EXECUTE {n.dashify} "); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(1, vm.getStack().size()); Assert.assertEquals("HELLO--WORLD", vm.getStack().pop()); }
@Test public void testType() throws RecognitionException, IOException { VM vm = new VM( "ENTRY { title } { } { label }" + "FUNCTION {presort} { cite$ 'sort.key$ := } ITERATE { presort } SORT FUNCTION {test} { type$ } ITERATE { test }"); List<BibEntry> v = new ArrayList<>(); v.add(TestVM.bibtexString2BibtexEntry("@article{a, author=\"AAA\"}")); v.add(TestVM.bibtexString2BibtexEntry("@book{b, author=\"BBB\"}")); v.add(TestVM.bibtexString2BibtexEntry("@misc{c, author=\"CCC\"}")); v.add(TestVM.bibtexString2BibtexEntry("@inproceedings{d, author=\"DDD\"}")); vm.run(v); Assert.assertEquals(4, vm.getStack().size()); Assert.assertEquals("inproceedings", vm.getStack().pop()); Assert.assertEquals("misc", vm.getStack().pop()); Assert.assertEquals("book", vm.getStack().pop()); Assert.assertEquals("article", vm.getStack().pop()); }
@Test public void testTextLength() throws RecognitionException, IOException { VM vm = new VM( "FUNCTION {test} {" + " \"hello world\" text.length$ " + " \"Hello {W}orld\" text.length$ " + " \"\" text.length$ " + " \"{A}{D}/{Cycle}\" text.length$ " + " \"{\\This is one character}\" text.length$ " + " \"{\\This {is} {one} {c{h}}aracter as well}\" text.length$ " + " \"{\\And this too\" text.length$ " + " \"These are {\\11}\" text.length$ " + "} " + "EXECUTE {test} "); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(11, vm.getStack().pop()); Assert.assertEquals(1, vm.getStack().pop()); Assert.assertEquals(1, vm.getStack().pop()); Assert.assertEquals(1, vm.getStack().pop()); Assert.assertEquals(8, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().pop()); Assert.assertEquals(11, vm.getStack().pop()); Assert.assertEquals(11, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testDuplicateEmptyPopSwapIf() throws RecognitionException, IOException { VM vm = new VM( "FUNCTION {emphasize} " + "{ duplicate$ empty$ " + " { pop$ \"\" } " + " { \"{\\em \" swap$ * \"}\" * } " + " if$ " + "} " + "FUNCTION {test} {" + " \"\" emphasize " + " \"Hello\" emphasize " + "}" + "EXECUTE {test} "); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals("{\\em Hello}", vm.getStack().pop()); Assert.assertEquals("", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVMArithmetic() throws RecognitionException, IOException { { VM vm = new VM("FUNCTION {test} { " + "#1 #1 + #5 #2 - }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals(3, vm.getStack().pop()); Assert.assertEquals(2, vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); } VM vm = new VM("FUNCTION {test} { " + "#1 \"HELLO\" + #5 #2 - }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); try { vm.run(v); Assert.fail(); } catch (VMException ignored) { // Ignored } }
@Test public void testCallType() throws RecognitionException, IOException { VM vm = new VM( "ENTRY { title } { } { label } FUNCTION {presort} { cite$ 'sort.key$ := } ITERATE { presort } READ SORT " + "FUNCTION {inproceedings}{ \"InProceedings called on \" title * } " + "FUNCTION {book}{ \"Book called on \" title * } " + " ITERATE { call.type$ }"); Vector<BibtexEntry> v = new Vector<>(); v.add(t1BibtexEntry()); v.add(TestVM.bibtexString2BibtexEntry("@book{test, title=\"Test\"}")); vm.run(v); Assert.assertEquals(2, vm.getStack().size()); Assert.assertEquals("Book called on Test", vm.getStack().pop()); Assert.assertEquals( "InProceedings called on Effective work practices for floss development: A model and propositions", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testVariables() throws RecognitionException, IOException { VM vm = new VM( " STRINGS { t } " + " FUNCTION {not} { { #0 } { #1 } if$ } " + " FUNCTION {n.dashify} { \"HELLO-WORLD\" 't := t empty$ not } " + " EXECUTE {n.dashify} "); vm.run(new Vector<BibtexEntry>()); Assert.assertEquals(VM.TRUE, vm.getStack().pop()); }
@Test public void testSubstring() throws RecognitionException, IOException { VM vm = new VM( "FUNCTION {test} " + "{ \"123456789\" #2 #1 substring$ " + // 2 " \"123456789\" #4 global.max$ substring$ " + // 456789 " \"123456789\" #1 #9 substring$ " + // 123456789 " \"123456789\" #1 #10 substring$ " + // 123456789 " \"123456789\" #1 #99 substring$ " + // 123456789 " \"123456789\" #-7 #3 substring$ " + // 123 " \"123456789\" #-1 #1 substring$ " + // 9 " \"123456789\" #-1 #3 substring$ " + // 789 " \"123456789\" #-2 #2 substring$ " + // 78 "} EXECUTE {test} "); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals("78", vm.getStack().pop()); Assert.assertEquals("789", vm.getStack().pop()); Assert.assertEquals("9", vm.getStack().pop()); Assert.assertEquals("123", vm.getStack().pop()); Assert.assertEquals("123456789", vm.getStack().pop()); Assert.assertEquals("123456789", vm.getStack().pop()); Assert.assertEquals("123456789", vm.getStack().pop()); Assert.assertEquals("456789", vm.getStack().pop()); Assert.assertEquals("2", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testLabel() throws RecognitionException, IOException { VM vm = new VM( "ENTRY { title } {} { label } " + "FUNCTION { test } { label #0 = title 'label := #5 label #6 pop$ } " + "READ " + "ITERATE { test }"); List<BibEntry> v = new ArrayList<>(); v.add(t1BibtexEntry()); vm.run(v); Assert.assertEquals( "Effective work practices for floss development: A model and propositions", vm.getStack().pop()); }
@Test public void testVMStringOps1() throws RecognitionException, IOException { VM vm = new VM( "FUNCTION {test} { \"H\" \"allo\" * \"Johnny\" add.period$ \"Johnny.\" add.period$" + "\"Johnny!\" add.period$ \"Johnny?\" add.period$ \"Johnny} }}}\" add.period$" + "\"Johnny!}\" add.period$ \"Johnny?}\" add.period$ \"Johnny.}\" add.period$ }" + "EXECUTE {test}"); Vector<BibtexEntry> v = new Vector<>(); vm.run(v); Assert.assertEquals("Johnny.}", vm.getStack().pop()); Assert.assertEquals("Johnny?}", vm.getStack().pop()); Assert.assertEquals("Johnny!}", vm.getStack().pop()); Assert.assertEquals("Johnny.}", vm.getStack().pop()); Assert.assertEquals("Johnny?", vm.getStack().pop()); Assert.assertEquals("Johnny!", vm.getStack().pop()); Assert.assertEquals("Johnny.", vm.getStack().pop()); Assert.assertEquals("Johnny.", vm.getStack().pop()); Assert.assertEquals("Hallo", vm.getStack().pop()); Assert.assertEquals(0, vm.getStack().size()); }
@Test public void testWidth() throws RecognitionException, IOException { VM vm = new VM( "ENTRY { " + " address " + " author " + " title " + " type " + "} {} { label } " + // "STRINGS { longest.label } " + // "INTEGERS { number.label longest.label.width } " + // "FUNCTION {initialize.longest.label} " + // "{ \"\" 'longest.label := " + // " #1 'number.label := " + // " #0 'longest.label.width := " + // "} " + // " " + // " FUNCTION {longest.label.pass} " + // " { number.label int.to.str$ 'label := " + // " number.label #1 + 'number.label := " + // " label width$ longest.label.width > " + // " { label 'longest.label := " + // " label width$ 'longest.label.width := " + // " } " + // " 'skip$ " + // " if$ " + // " } " + // " " + // " EXECUTE {initialize.longest.label} " + // " " + // " ITERATE {longest.label.pass} " + // "FUNCTION {begin.bib} " + // "{ preamble$ empty$" + // " 'skip$" + // " { preamble$ write$ newline$ }" + // " if$" + // " \"\\begin{thebibliography}{\" longest.label * \"}\" *" + // "}" + // "EXECUTE {begin.bib}" + // ""); // Vector<BibtexEntry> v = new Vector<>(); v.add(t1BibtexEntry()); vm.run(v); Assert.assertTrue(vm.getIntegers().containsKey("longest.label.width")); Assert.assertEquals("\\begin{thebibliography}{1}", vm.getStack().pop()); }