Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
method2testcases
stringlengths
118
6.63k
### Question: DailyLogListener extends RotateLogListener { public void setPrefix(String prefix) { this.prefix = prefix; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetPrefix() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setPrefix("testDailyLogListenerPrefix"); assertEquals("testDailyLogListenerPrefix", dailyLogListener.getPrefix(), "dailyLogListener.getPrefix()"); }
### Question: DailyLogListener extends RotateLogListener { public void setRotateCount(int rotateCount) { this.rotateCount = rotateCount; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetRotateCount() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setRotateCount(100); assertEquals(100, dailyLogListener.getRotateCount(), "dailyLogListener.getRotateCount()"); }
### Question: DailyLogListener extends RotateLogListener { public void setSuffix(String suffix) { this.suffix = suffix; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetSuffix() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setSuffix("testDailyLogListenerSuffix"); assertEquals("testDailyLogListenerSuffix", dailyLogListener.getSuffix(), "dailyLogListener.getSuffix()"); }
### Question: DailyLogListener extends RotateLogListener { public void setMaxAge(long maxAge) { this.maxAge = maxAge; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetMaxAge() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); long maxAge = 7*24*3600*1000; dailyLogListener.setMaxAge(maxAge); assertEquals(maxAge, dailyLogListener.getMaxAge(), "dailyLogListener.getMaxAge()"); }
### Question: LogEvent { public void addMessage (Object msg) { payLoad.add (msg); } LogEvent(String tag); LogEvent(); LogEvent(String tag, Object msg); LogEvent(LogSource source, String tag); LogEvent(LogSource source, String tag, Object msg); String getTag(); void setTag(String tag); void addMessage(Object msg); void addMessage(String tagname, String message); LogSource getSource(); void setSource(LogSource source); void setNoArmor(boolean noArmor); void dump(PrintStream p, String outer); String getRealm(); List<Object> getPayLoad(); String toString(String indent); String toString(); boolean isHonorSourceLogger(); }### Answer: @Test public void testAddMessage() throws Throwable { LogEvent logEvent = new LogEvent(new ISO87APackagerBBitmap(), "testLogEventTag", Integer.valueOf(-2)); logEvent.addMessage("false"); assertEquals(2, logEvent.getPayLoad().size(), "logEvent.payLoad.size()"); assertEquals("false", logEvent.getPayLoad().get(1), "logEvent.payLoad.get(1)"); }
### Question: LogEvent { public void dump (PrintStream p, String outer) { try { String indent = dumpHeader (p, outer); if (payLoad.isEmpty()) { if (tag != null) p.println (indent + "<" + tag + "/>"); } else { String newIndent; if (tag != null) { if (!tag.isEmpty()) p.println (indent + "<" + tag + ">"); newIndent = indent + " "; } else newIndent = ""; synchronized (payLoad) { for (Object o : payLoad) { if (o instanceof Loggeable) ((Loggeable) o).dump(p, newIndent); else if (o instanceof SQLException) { SQLException e = (SQLException) o; p.println(newIndent + "<SQLException>" + e.getMessage() + "</SQLException>"); p.println(newIndent + "<SQLState>" + e.getSQLState() + "</SQLState>"); p.println(newIndent + "<VendorError>" + e.getErrorCode() + "</VendorError>"); ((Throwable) o).printStackTrace(p); } else if (o instanceof Throwable) { p.println(newIndent + "<exception name=\"" + ((Throwable) o).getMessage() + "\">"); p.print(newIndent); ((Throwable) o).printStackTrace(p); p.println(newIndent + "</exception>"); } else if (o instanceof Object[]) { Object[] oa = (Object[]) o; p.print(newIndent + "["); for (int j = 0; j < oa.length; j++) { if (j > 0) p.print(","); p.print(oa[j].toString()); } p.println("]"); } else if (o instanceof Element) { p.println(""); XMLOutputter out = new XMLOutputter(Format.getPrettyFormat()); out.getFormat().setLineSeparator("\n"); try { out.output((Element) o, p); } catch (IOException ex) { ex.printStackTrace(p); } p.println(""); } else if (o != null) { p.println(newIndent + o.toString()); } else { p.println(newIndent + "null"); } } } if (tag != null && !tag.isEmpty()) p.println (indent + "</" + tag + ">"); } } catch (Throwable t) { t.printStackTrace(p); } finally { dumpTrailer (p, outer); } } LogEvent(String tag); LogEvent(); LogEvent(String tag, Object msg); LogEvent(LogSource source, String tag); LogEvent(LogSource source, String tag, Object msg); String getTag(); void setTag(String tag); void addMessage(Object msg); void addMessage(String tagname, String message); LogSource getSource(); void setSource(LogSource source); void setNoArmor(boolean noArmor); void dump(PrintStream p, String outer); String getRealm(); List<Object> getPayLoad(); String toString(String indent); String toString(); boolean isHonorSourceLogger(); }### Answer: @Test public void testDump() throws Throwable { PrintStream p = new PrintStream(new ByteArrayOutputStream()); new LogEvent("testLogEventTag").dump(p, "\r\n"); assertTrue(true, "Test completed without Exception"); } @Test public void testDump3() throws Throwable { new LogEvent(new ThreadPool(0, 0), "testString", null).dump(new PrintStream(new ByteArrayOutputStream(), true), "a42"); assertEquals("a42", "a42", "\"a42\""); } @Test public void testDumpThrowsNullPointerException() throws Throwable { try { new LogEvent("testLogEventTag").dump(null, "testLogEventIndent"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.io.PrintStream.println(String)\" because \"p\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: LogEvent { public String getRealm() { return source != null ? source.getRealm() : ""; } LogEvent(String tag); LogEvent(); LogEvent(String tag, Object msg); LogEvent(LogSource source, String tag); LogEvent(LogSource source, String tag, Object msg); String getTag(); void setTag(String tag); void addMessage(Object msg); void addMessage(String tagname, String message); LogSource getSource(); void setSource(LogSource source); void setNoArmor(boolean noArmor); void dump(PrintStream p, String outer); String getRealm(); List<Object> getPayLoad(); String toString(String indent); String toString(); boolean isHonorSourceLogger(); }### Answer: @Test public void testGetRealm() throws Throwable { LogSource source = new ISO87APackagerBBitmap(); LogEvent logEvent = new LogEvent(source, "testLogEventTag", Integer.valueOf(-2)); String result = logEvent.getRealm(); assertNull(result, "result"); assertSame(source, logEvent.getSource(), "logEvent.source"); }
### Question: LogEvent { public LogSource getSource() { return source; } LogEvent(String tag); LogEvent(); LogEvent(String tag, Object msg); LogEvent(LogSource source, String tag); LogEvent(LogSource source, String tag, Object msg); String getTag(); void setTag(String tag); void addMessage(Object msg); void addMessage(String tagname, String message); LogSource getSource(); void setSource(LogSource source); void setNoArmor(boolean noArmor); void dump(PrintStream p, String outer); String getRealm(); List<Object> getPayLoad(); String toString(String indent); String toString(); boolean isHonorSourceLogger(); }### Answer: @Test public void testGetSource() throws Throwable { LogSource source = new ISO93APackager(); LogSource result = new LogEvent(source, "x", Integer.valueOf(64)).getSource(); assertSame(source, result, "result"); }
### Question: LogEvent { public void setSource(LogSource source) { this.source = source; } LogEvent(String tag); LogEvent(); LogEvent(String tag, Object msg); LogEvent(LogSource source, String tag); LogEvent(LogSource source, String tag, Object msg); String getTag(); void setTag(String tag); void addMessage(Object msg); void addMessage(String tagname, String message); LogSource getSource(); void setSource(LogSource source); void setNoArmor(boolean noArmor); void dump(PrintStream p, String outer); String getRealm(); List<Object> getPayLoad(); String toString(String indent); String toString(); boolean isHonorSourceLogger(); }### Answer: @Test public void testSetSource() throws Throwable { LogEvent logEvent = new LogEvent(new Log(), "testLogEventTag"); LogSource source = new ISOBaseValidatingPackager(); logEvent.setSource(source); assertSame(source, logEvent.getSource(), "logEvent.source"); }
### Question: ThreadPool extends ThreadGroup implements LogSource, Loggeable, Configurable, ThreadPoolMBean { public synchronized void execute(Runnable action) throws Closed { if (!pool.ready()) throw new Closed(); if (++jobs % this.maxPoolSize == 0 || pool.consumerCount() <= 0) supervise(); if (running < maxPoolSize && pool.consumerDeficit() >= 0) { new PooledThread().start(); running++; } available--; pool.enqueue (action); } ThreadPool(int poolSize, int maxPoolSize); ThreadPool(int poolSize, int maxPoolSize, String name); ThreadPool(); void close(); synchronized void execute(Runnable action); void dump(PrintStream p, String indent); int getJobCount(); int getPoolSize(); int getMaxPoolSize(); int getActiveCount(); int getIdleCount(); synchronized int getAvailableCount(); int getPendingCount(); void supervise(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setConfiguration(Configuration cfg); static ThreadPool getThreadPool(java.lang.String name); static final int DEFAULT_MAX_THREADS; }### Answer: @Test public void testRunNames() throws Throwable { ThreadPool threadPool = new ThreadPool(1, 2); threadPool.execute(new TestTask()); ISOUtil.sleep(20); threadPool.execute(new TestTask()); ISOUtil.sleep(20); Thread[] tl = new Thread[threadPool.activeCount()]; threadPool.enumerate(tl); for (Thread t :tl ) assertThat(t.getName(), new MatchesPattern(Pattern.compile("ThreadPool.PooledThread-\\d+-(running|idle)"))); }
### Question: Dumpable implements Loggeable { public Dumpable (String name, byte[] payload) { this.name = name; this.payload = payload; } Dumpable(String name, byte[] payload); void dump(PrintStream p, String indent); }### Answer: @Test public void testDumpable() { assertThat(dumpable.name, is("testingDumpable")); assertThat(dumpable.payload, is("987654321".getBytes())); }
### Question: Dumpable implements Loggeable { public void dump(PrintStream p, String indent) { p.println (indent + "<" + name + ">"); p.print (ISOUtil.hexdump (payload)); p.println (indent + "</" + name + ">"); } Dumpable(String name, byte[] payload); void dump(PrintStream p, String indent); }### Answer: @Test public void testDump() { ByteArrayOutputStream baos = new ByteArrayOutputStream(); PrintStream p = new PrintStream(baos); dumpable.dump(p, ":-o"); String lineSep = System.getProperty ("line.separator"); String expected = ":-o<testingDumpable>" + lineSep + "0000 39 38 37 36 35 34 33 32 31 987654321" + lineSep + ":-o</testingDumpable>" + lineSep; assertThat(baos.toString(), is(expected)); }
### Question: LogUtil { public static boolean needsCDATA(String s) { return xmlReservedPattern.matcher(s).find(); } static void dump(PrintStream p, String indent, String s); static boolean needsCDATA(String s); static final Pattern xmlReservedPattern; }### Answer: @Test public void testNeedsCDATAjson() { String json = "{\"amount\": 123}"; assertFalse(LogUtil.needsCDATA(json)); } @Test public void testNeedsCDATAxml() { String xml = "<tag>hello</tag>"; assertTrue(LogUtil.needsCDATA(xml)); } @Test public void testNeedsCDATAapos() { String apostrophe = "Rock'n roll"; assertFalse(LogUtil.needsCDATA(apostrophe)); } @Test public void testNeedsCDATAamp() { String amp = "This & that"; assertTrue(LogUtil.needsCDATA(amp)); } @Test public void testNeedsCDATA() { String normal = "The quick brown fox jumps over the lazy dog"; assertFalse(LogUtil.needsCDATA(normal)); }
### Question: ProtectedLogListener implements LogListener, Configurable { public LogEvent log (LogEvent ev) { synchronized (ev.getPayLoad()) { final List<Object> payLoad = ev.getPayLoad(); int size = payLoad.size(); for (int i=0; i<size; i++) { Object obj = payLoad.get (i); if (obj instanceof ISOMsg) { ISOMsg m = (ISOMsg) ((ISOMsg) obj).clone(); try { checkProtected (m); checkHidden (m); } catch (ISOException e) { ev.addMessage (e); } payLoad.set (i, m); } else if (obj instanceof SimpleMsg){ try { checkProtected((SimpleMsg) obj); } catch (ISOException e) { ev.addMessage (e); } } } } return ev; } ProtectedLogListener(); void setConfiguration(Configuration cfg); LogEvent log(LogEvent ev); static final String WIPED; static final byte[] BINARY_WIPED; }### Answer: @Test public void testLogThrowsNullPointerException() throws Throwable { try { new ProtectedLogListener().log(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.util.LogEvent.getPayLoad()\" because \"ev\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: ProtectedLogListener implements LogListener, Configurable { public void setConfiguration (Configuration cfg) throws ConfigurationException { this.cfg = cfg; protectFields = ISOUtil.toStringArray (cfg.get ("protect", "")); wipeFields = ISOUtil.toStringArray (cfg.get ("wipe", "")); } ProtectedLogListener(); void setConfiguration(Configuration cfg); LogEvent log(LogEvent ev); static final String WIPED; static final byte[] BINARY_WIPED; }### Answer: @Test public void testSetConfiguration() throws Throwable { ProtectedLogListener protectedLogListener = new ProtectedLogListener(); Configuration cfg = new SimpleConfiguration(); protectedLogListener.setConfiguration(cfg); assertEquals(0, protectedLogListener.protectFields.length, "protectedLogListener.protectFields.length"); assertEquals(0, protectedLogListener.wipeFields.length, "protectedLogListener.wipeFields.length"); assertSame(cfg, protectedLogListener.cfg, "protectedLogListener.cfg"); } @Test public void testSetConfigurationThrowsNullPointerException() throws Throwable { ProtectedLogListener protectedLogListener = new ProtectedLogListener(); Configuration cfg = new SubConfiguration(); try { protectedLogListener.setConfiguration(cfg); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertSame(cfg, protectedLogListener.cfg, "protectedLogListener.cfg"); if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.core.Configuration.get(String, String)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(protectedLogListener.wipeFields, "protectedLogListener.wipeFields"); assertNull(protectedLogListener.protectFields, "protectedLogListener.protectFields"); } }
### Question: ZipUtil { public static void zipFile(File input, File output) throws IOException { FileInputStream in = null; ZipOutputStream out = null; try { in = new FileInputStream(input); out = new ZipOutputStream(new FileOutputStream(output)); out.putNextEntry(new ZipEntry(input.getName())); byte[] buffer = new byte[4096]; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); } out.flush(); out.closeEntry(); out.finish(); } finally{ if (in != null) { in.close(); } if (out != null) { out.close(); } } } static void zipFile(File input, File output); }### Answer: @Test public void testZipFile() throws Throwable { File testFile = File.createTempFile("testFile",".txt"); File testFileZip = File.createTempFile("testFile",".zip"); PrintWriter writer = new PrintWriter(testFile); writer.write("this is a test"); writer.close(); assertThat(testFile.exists(), is(true)); assertThat(testFileZip.exists(), is(true)); assertThat(testFileZip.length(), is(0L)); ZipUtil.zipFile(testFile, testFileZip); assertThat(testFileZip.length(), not(0L)); ZipFile zipFile = new ZipFile(testFileZip); ZipEntry zipEntry = zipFile.getEntry(testFile.getName()); assertThat(zipEntry, notNullValue()); assertThat(new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry))).readLine(), is("this is a test")); zipFile.close(); testFile.delete(); testFileZip.delete(); }
### Question: IssuerApplicationData implements Loggeable { @Override public String toString() { return iad; } IssuerApplicationData(String hexIAD); IssuerApplicationData(byte[] iad); String getDerivationKeyIndex(); String getCryptogramVersionNumber(); String getCommonCoreIdentifier(); String getCardVerificationResults(); String getDAC(); String getCounters(); Format getFormat(); String getIssuerDiscretionaryData(); @Override String toString(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testToString() { String hexIAD = "0110250000044000DAC10000000000000000"; IssuerApplicationData iad = new IssuerApplicationData(hexIAD); assertEquals(hexIAD, iad.toString()); }
### Question: SecureKeyBlockBuilder { public String toKeyBlock(SecureKeyBlock skb) { StringBuilder sb = new StringBuilder(); sb.append(skb.getKeyBlockVersion()); sb.append(String.format("%04d", skb.getKeyBlockLength())); sb.append(skb.getKeyUsage().getCode()); sb.append(skb.getAlgorithm().getCode()); sb.append(skb.getModeOfUse().getCode()); sb.append(skb.getKeyVersion()); sb.append(skb.getExportability().getCode()); Map<String, String> optHdr = skb.getOptionalHeaders(); sb.append(String.format("%02d", optHdr.size())); sb.append(skb.getReserved()); for (Entry<String, String> ent : optHdr.entrySet()) { sb.append(ent.getKey()); sb.append(String.format("%02X", ent.getValue().length() + SIZE_OPTHDR_ID + SIZE_OPTHDR_LENGTH)); sb.append(ent.getValue()); } byte[] b = skb.getKeyBytes(); if (b != null) sb.append(ISOUtil.hexString(b)); b = skb.getKeyBlockMAC(); if (b != null) sb.append(ISOUtil.hexString(skb.getKeyBlockMAC())); return sb.toString(); } private SecureKeyBlockBuilder(); static SecureKeyBlockBuilder newBuilder(); SecureKeyBlockBuilder with4characterMACVersions(String versions); SecureKeyBlock build(CharSequence data); String toKeyBlock(SecureKeyBlock skb); }### Answer: @Test public void testToKeyBlock() { String data = "E0046V2TGc3E0233" + OPTHEADER_KS + OPTHEADER_KV + ISOUtil.hexString(KEYBLOCK_MAC8); ret = instance.build(data); assertEquals(data, instance.toKeyBlock(ret)); }
### Question: SecureKey implements Serializable, Loggeable { public byte[] getKeyBytes () { return keyBytes; } void setKeyBytes(byte[] keyBytes); byte[] getKeyBytes(); void setKeyCheckValue(byte[] keyCheckValue); byte[] getKeyCheckValue(); void setKeyLength(short keyLength); short getKeyLength(); void setKeyType(String keyType); String getKeyType(); void setScheme(KeyScheme scheme); abstract KeyScheme getScheme(); String getKeyName(); void setKeyName(String keyName); }### Answer: @Test public void testGetKeyBytes() throws Throwable { SecureKey secureDESKey = new SecureDESKey(); byte[] keyBytes = new byte[0]; secureDESKey.setKeyBytes(keyBytes); byte[] result = secureDESKey.getKeyBytes(); assertSame(keyBytes, result, "result"); } @Test public void testGetKeyBytes1() throws Throwable { byte[] keyBytes = new byte[3]; byte[] result = new SecureDESKey((short) 100, "testSecureKeyKeyType", keyBytes, keyBytes).getKeyBytes(); assertSame(keyBytes, result, "result"); assertEquals((byte) 0, keyBytes[0], "keyBytes[0]"); }
### Question: SecureKey implements Serializable, Loggeable { public short getKeyLength () { return keyLength; } void setKeyBytes(byte[] keyBytes); byte[] getKeyBytes(); void setKeyCheckValue(byte[] keyCheckValue); byte[] getKeyCheckValue(); void setKeyLength(short keyLength); short getKeyLength(); void setKeyType(String keyType); String getKeyType(); void setScheme(KeyScheme scheme); abstract KeyScheme getScheme(); String getKeyName(); void setKeyName(String keyName); }### Answer: @Test public void testGetKeyLength() throws Throwable { SecureKey secureDESKey = new SecureDESKey(); secureDESKey.setKeyLength((short) 100); short result = secureDESKey.getKeyLength(); assertEquals((short) 100, result, "result"); }
### Question: SecureKey implements Serializable, Loggeable { public String getKeyType () { return this.keyType; } void setKeyBytes(byte[] keyBytes); byte[] getKeyBytes(); void setKeyCheckValue(byte[] keyCheckValue); byte[] getKeyCheckValue(); void setKeyLength(short keyLength); short getKeyLength(); void setKeyType(String keyType); String getKeyType(); void setScheme(KeyScheme scheme); abstract KeyScheme getScheme(); String getKeyName(); void setKeyName(String keyName); }### Answer: @Test public void testGetKeyType() throws Throwable { SecureKey secureDESKey = new SecureDESKey(); secureDESKey.setKeyType("testSecureKeyKeyType"); String result = secureDESKey.getKeyType(); assertEquals("testSecureKeyKeyType", result, "result"); }
### Question: SecureKey implements Serializable, Loggeable { public void setKeyBytes (byte[] keyBytes) { this.keyBytes = keyBytes; } void setKeyBytes(byte[] keyBytes); byte[] getKeyBytes(); void setKeyCheckValue(byte[] keyCheckValue); byte[] getKeyCheckValue(); void setKeyLength(short keyLength); short getKeyLength(); void setKeyType(String keyType); String getKeyType(); void setScheme(KeyScheme scheme); abstract KeyScheme getScheme(); String getKeyName(); void setKeyName(String keyName); }### Answer: @Test public void testSetKeyBytes() throws Throwable { byte[] keyBytes = new byte[3]; SecureKey secureDESKey = new SecureDESKey((short) 100, "testSecureKeyKeyType", keyBytes, keyBytes); secureDESKey.setKeyBytes(keyBytes); assertSame(keyBytes, ((SecureDESKey) secureDESKey).keyBytes, "(SecureDESKey) secureDESKey.keyBytes"); }
### Question: SecureKey implements Serializable, Loggeable { public void setKeyLength (short keyLength) { this.keyLength = keyLength; } void setKeyBytes(byte[] keyBytes); byte[] getKeyBytes(); void setKeyCheckValue(byte[] keyCheckValue); byte[] getKeyCheckValue(); void setKeyLength(short keyLength); short getKeyLength(); void setKeyType(String keyType); String getKeyType(); void setScheme(KeyScheme scheme); abstract KeyScheme getScheme(); String getKeyName(); void setKeyName(String keyName); }### Answer: @Test public void testSetKeyLength() throws Throwable { byte[] keyBytes = new byte[3]; new SecureDESKey((short) 100, "testSecureKeyKeyType", keyBytes, keyBytes).getKeyBytes(); SecureKey secureDESKey = new SecureDESKey((short) 1000, "testSecureKeyKeyType1", "3check-value>".getBytes(), keyBytes); secureDESKey.setKeyLength((short) 100); assertEquals((short) 100, ((SecureDESKey) secureDESKey).keyLength, "(SecureDESKey) secureDESKey.keyLength"); }
### Question: SecureKey implements Serializable, Loggeable { public void setKeyType (String keyType) { this.keyType = keyType; } void setKeyBytes(byte[] keyBytes); byte[] getKeyBytes(); void setKeyCheckValue(byte[] keyCheckValue); byte[] getKeyCheckValue(); void setKeyLength(short keyLength); short getKeyLength(); void setKeyType(String keyType); String getKeyType(); void setScheme(KeyScheme scheme); abstract KeyScheme getScheme(); String getKeyName(); void setKeyName(String keyName); }### Answer: @Test public void testSetKeyType() throws Throwable { byte[] keyBytes = new byte[3]; new SecureDESKey((short) 100, "testSecureKeyKeyType", keyBytes, keyBytes).getKeyBytes(); SecureKey secureDESKey = new SecureDESKey((short) 1000, "testSecureKeyKeyType1", "3check-value>".getBytes(), keyBytes); secureDESKey.setKeyType("testSecureKeyKeyType"); assertEquals("testSecureKeyKeyType", ((SecureDESKey) secureDESKey).keyType, "(SecureDESKey) secureDESKey.keyType"); }
### Question: TLVList implements Serializable, Loggeable { public List<TLVMsg> getTags() { return tags; } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testConstructor() { instance = new TLVList(); assertTrue(instance.getTags().isEmpty()); } @Test public void testTags() { List<TLVMsg> result = instance.getTags(); assertTrue(result.isEmpty()); }
### Question: TLVList implements Serializable, Loggeable { public void deleteByIndex(int index) { tags.remove(index); } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testDeleteByIndex() { instance.append(TEST_TAG1, new byte[0]); instance.deleteByIndex(0); assertTrue(instance.getTags().isEmpty()); } @Test public void testDeleteByIndexThrowsIndexOutOfBounds() { assertThrows(IndexOutOfBoundsException.class, () -> { instance.deleteByIndex(TEST_TAG1); }); }
### Question: Util { public static void adjustDESParity (byte[] bytes) { for (int i = 0; i < bytes.length; i++) { int b = bytes[i]; bytes[i] = (byte)(b & 0xfe | (b >> 1 ^ b >> 2 ^ b >> 3 ^ b >> 4 ^ b >> 5 ^ b >> 6 ^ b >> 7 ^ 0x01) & 0x01); } } static void adjustDESParity(byte[] bytes); static boolean isDESParityAdjusted(byte[] bytes); }### Answer: @Test public void testAdjustDESParity() throws Throwable { byte[] bytes = new byte[1]; Util.adjustDESParity(bytes); assertEquals((byte) 1, bytes[0], "bytes[0]"); } @Test public void testAdjustDESParity1() throws Throwable { byte[] bytes = new byte[0]; Util.adjustDESParity(bytes); assertEquals(0, bytes.length, "bytes.length"); } @Test public void testAdjustDESParityThrowsNullPointerException() throws Throwable { try { Util.adjustDESParity(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot read the array length because \"bytes\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: Util { public static boolean isDESParityAdjusted (byte[] bytes) { byte[] correct = bytes.clone(); adjustDESParity(correct); return Arrays.equals(bytes, correct); } static void adjustDESParity(byte[] bytes); static boolean isDESParityAdjusted(byte[] bytes); }### Answer: @Test public void testIsDESParityAdjusted() throws Throwable { byte[] bytes = new byte[2]; boolean result = Util.isDESParityAdjusted(bytes); assertFalse(result, "result"); } @Test public void testIsDESParityAdjusted1() throws Throwable { byte[] bytes = new byte[0]; boolean result = Util.isDESParityAdjusted(bytes); assertTrue(result, "result"); } @Test public void testIsDESParityAdjustedThrowsNullPointerException() throws Throwable { try { Util.isDESParityAdjusted(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"[B.clone()\" because \"bytes\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: SystemSeed { public static byte[] getSeed (int l) { return getSeed(0, l); } static byte[] getSeed(int l); static byte[] getSeed(int offset, int l); }### Answer: @Test public void testWellKnownSeeds() throws Throwable { assertEquals("371B4CF737319AC15BD6B18DE9E8B8537D2D2CC6323B4E728C8A06C654FBBA06", ISOUtil.hexString(ISOUtil.xor(SystemSeed.getSeed(16,32), SystemSeed.getSeed(4064-32))), "Invalid seed 0"); assertEquals("6835BEFB07E7965940A99D46C7FAC87561DCB1FD7BF4932DB5ACC1E0529B1AE891B0368E14D5F9BFFC74E380426C3A7B", ISOUtil.hexString(ISOUtil.xor(SystemSeed.getSeed(0,1024), SystemSeed.getSeed(2048,48))), "Invalid seed 1"); assertEquals("6835BEFB07E7965940A99D46C7FAC87561DCB1FD7BF4932DB5ACC1E0529B1AE891B0368E14D5F9BFFC74E380426C3A7B", ISOUtil.hexString(ISOUtil.xor(SystemSeed.getSeed(0,1024), SystemSeed.getSeed(6144,48))), "Invalid seed 3"); assertEquals(ISOUtil.hexString(new byte[8192]), ISOUtil.hexString(ISOUtil.xor(SystemSeed.getSeed(1,8192), SystemSeed.getSeed(4097,16384))), "Invalid seed 3"); }
### Question: SecureKeySpec implements Serializable, Loggeable { @Override public void dump(PrintStream p, String indent) { String inner = indent + " "; p.print(indent + "<secure-key-spec"); if (scheme != null) p.print(" scheme=\"" + scheme + "\""); if (keyName != null) p.print(" name=\"" + keyName + "\""); p.println(">"); if (getKeyLength() > 0) p.println(inner + "<length>" + getKeyLength() + "</length>"); if (getKeyType() != null) { p.println(inner + "<type>" + getKeyType() + "</type>"); p.println(inner + "<variant>" + getVariant() + "</variant>"); } String keyblok = formKeyHeader(inner); if (keyblok != null) { p.println(inner + "<header>"); p.print(keyblok); p.println(inner + "</header>"); } if (!optionalHeaders.isEmpty()) { p.println(inner + "<optional-header>"); String inner2 = inner + " "; for (Entry<String, String> ent : optionalHeaders.entrySet()) p.println(inner2 + "<entry id=\""+ ent.getKey() + "\" value=\""+ ent.getValue()+ "\"/>"); p.println(inner + "</optional-header>"); } if (getKeyBytes() != null) p.println(inner + "<data>" + ISOUtil.hexString(getKeyBytes()) + "</data>"); if (getKeyBlockMAC() != null) p.println(inner + "<mac>" + ISOUtil.hexString(getKeyBlockMAC()) + "</mac>"); if (getKeyCheckValue() != null) p.println(inner + "<check-value>" + ISOUtil.hexString(getKeyCheckValue()) + "</check-value>"); p.println(indent + "</secure-key-spec>"); } SecureKeySpec(); void setScheme(KeyScheme scheme); KeyScheme getScheme(); void setKeyLength(int keyLength); int getKeyLength(); void setKeyType(String keyType); String getKeyType(); void setVariant(int variant); int getVariant(); char getKeyBlockVersion(); void setKeyBlockVersion(char keyBlockVersion); KeyUsage getKeyUsage(); void setKeyUsage(KeyUsage keyUsage); Algorithm getAlgorithm(); void setAlgorithm(Algorithm algorithm); ModeOfUse getModeOfUse(); void setModeOfUse(ModeOfUse modeOfUse); String getKeyVersion(); void setKeyVersion(String keyVersion); Exportability getExportability(); void setExportability(Exportability exportability); String getReserved(); void setReserved(String reserved); Map<String, String> getOptionalHeaders(); byte[] getKeyBlockMAC(); void setKeyBlockMAC(byte[] keyBlockMAC); void setKeyBytes(byte[] keyBytes); byte[] getKeyBytes(); void setKeyCheckValue(byte[] keyCheckValue); byte[] getKeyCheckValue(); String getKeyName(); void setKeyName(String keyName); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testDumpEmpty() { String indent = "____"; instance.dump(ps, indent); StringBuilder sb = new StringBuilder(128); sb.append(indent).append("<secure-key-spec>").append(NL); sb.append(indent).append("</secure-key-spec>").append(NL); assertEquals(sb.toString(), os.toString()); }
### Question: CryptographicServiceMessage implements Loggeable { public void addField(String tag, String content) { Objects.requireNonNull(tag, "The tag is required"); Objects.requireNonNull(content, "The content is required"); tag = tag.toUpperCase(); fields.put(tag, content); orderedTags.add(tag); } CryptographicServiceMessage(); CryptographicServiceMessage(String mcl); void setMCL(String mcl); String getMCL(); void addField(String tag, String content); String getFieldContent(String tag); @Override String toString(); @Override void dump(PrintStream p, String indent); static CryptographicServiceMessage parse(String csmString); static final String MCL_RSI; static final String MCL_KSM; static final String MCL_RSM; static final String MCL_ESM; static final String TAG_RCV; static final String TAG_ORG; static final String TAG_SVR; static final String TAG_KD; static final String TAG_CTP; static final String TAG_CTR; static final String TAG_ERF; }### Answer: @Test void testAddField() { instance.addField("testTag", "testContent"); assertEquals(1, instance.fields.size()); assertEquals("testContent", instance.fields.get("TESTTAG")); assertEquals(1, instance.orderedTags.size()); assertEquals("TESTTAG", instance.orderedTags.get(0)); } @Test void testAddFieldThrowsNullPointerException() { thrown = assertThrows(NullPointerException.class, () -> instance.addField("testTag", null) ); assertEquals("The content is required", thrown.getMessage()); assertEquals(0, instance.fields.size()); assertEquals(0, instance.orderedTags.size()); } @Test void testAddFieldThrowsNullPointerException1() { thrown = assertThrows(NullPointerException.class, () -> instance.addField(null, "testContent") ); assertEquals("The tag is required", thrown.getMessage()); assertEquals(0, instance.fields.size()); assertEquals(0, instance.orderedTags.size()); }
### Question: CryptographicServiceMessage implements Loggeable { public void setMCL(String mcl) { this.mcl = mcl; } CryptographicServiceMessage(); CryptographicServiceMessage(String mcl); void setMCL(String mcl); String getMCL(); void addField(String tag, String content); String getFieldContent(String tag); @Override String toString(); @Override void dump(PrintStream p, String indent); static CryptographicServiceMessage parse(String csmString); static final String MCL_RSI; static final String MCL_KSM; static final String MCL_RSM; static final String MCL_ESM; static final String TAG_RCV; static final String TAG_ORG; static final String TAG_SVR; static final String TAG_KD; static final String TAG_CTP; static final String TAG_CTR; static final String TAG_ERF; }### Answer: @Test void testConstructor1() { instance.setMCL("testMcl"); assertEquals(0, instance.fields.size()); assertEquals(0, instance.orderedTags.size()); assertEquals("testMcl", instance.mcl); } @Test void testSetMCL() { instance.setMCL("testMcl"); assertEquals("testMcl", instance.mcl); }
### Question: CryptographicServiceMessage implements Loggeable { @Override public void dump (PrintStream p, String indent) { String inner = indent + " "; p.print(indent + "<csm"); p.print(" class=\"" + getMCL() + "\""); p.println(">"); for (String tag : orderedTags) { p.println(inner + "<field tag=\"" + tag + "\" value=\"" + getFieldContent(tag) + "\"/>"); } p.println(indent + "</csm>"); } CryptographicServiceMessage(); CryptographicServiceMessage(String mcl); void setMCL(String mcl); String getMCL(); void addField(String tag, String content); String getFieldContent(String tag); @Override String toString(); @Override void dump(PrintStream p, String indent); static CryptographicServiceMessage parse(String csmString); static final String MCL_RSI; static final String MCL_KSM; static final String MCL_RSM; static final String MCL_ESM; static final String TAG_RCV; static final String TAG_ORG; static final String TAG_SVR; static final String TAG_KD; static final String TAG_CTP; static final String TAG_CTR; static final String TAG_ERF; }### Answer: @Test void testDump() throws Throwable { PrintStream p = new PrintStream(new ByteArrayOutputStream(), true, "UTF-8"); instance.setMCL("testMcl"); instance.dump(p, "testIndent"); assertTrue(true, "Test completed without Exception"); }
### Question: CryptographicServiceMessage implements Loggeable { public String getFieldContent(String tag) { return fields.get(tag.toUpperCase()); } CryptographicServiceMessage(); CryptographicServiceMessage(String mcl); void setMCL(String mcl); String getMCL(); void addField(String tag, String content); String getFieldContent(String tag); @Override String toString(); @Override void dump(PrintStream p, String indent); static CryptographicServiceMessage parse(String csmString); static final String MCL_RSI; static final String MCL_KSM; static final String MCL_RSM; static final String MCL_ESM; static final String TAG_RCV; static final String TAG_ORG; static final String TAG_SVR; static final String TAG_KD; static final String TAG_CTP; static final String TAG_CTR; static final String TAG_ERF; }### Answer: @Test void testGetFieldContent() { instance.setMCL("testMcl"); String result = instance.getFieldContent("testTag"); assertNull(result, "result"); }
### Question: CryptographicServiceMessage implements Loggeable { public String getMCL() { return mcl; } CryptographicServiceMessage(); CryptographicServiceMessage(String mcl); void setMCL(String mcl); String getMCL(); void addField(String tag, String content); String getFieldContent(String tag); @Override String toString(); @Override void dump(PrintStream p, String indent); static CryptographicServiceMessage parse(String csmString); static final String MCL_RSI; static final String MCL_KSM; static final String MCL_RSM; static final String MCL_ESM; static final String TAG_RCV; static final String TAG_ORG; static final String TAG_SVR; static final String TAG_KD; static final String TAG_CTP; static final String TAG_CTR; static final String TAG_ERF; }### Answer: @Test void testGetMCL() { instance.setMCL("testCryptographicServiceMessageMcl"); String result = instance.getMCL(); assertEquals("testCryptographicServiceMessageMcl", result, "result"); } @Test void testGetMCL1() { String result = instance.getMCL(); assertNull(result, "result"); }
### Question: TLVList implements Serializable, Loggeable { public void deleteByTag(int tag) { List<TLVMsg> t = new ArrayList<>(); for (TLVMsg tlv2 : tags) { if (tlv2.getTag() == tag) t.add(tlv2); } tags.removeAll(t); } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testDeleteByTag() { instance.append(TEST_TAG1, new byte[1]); instance.append(TEST_TAG2, new byte[0]); instance.deleteByTag(TEST_TAG1); assertFalse(instance.getTags().isEmpty()); }
### Question: CryptographicServiceMessage implements Loggeable { public static CryptographicServiceMessage parse(String csmString) throws ParsingException { CryptographicServiceMessage csm = new CryptographicServiceMessage(); StringTokenizer st = new StringTokenizer(csmString, "() \t\n\r\f"); if (!st.nextToken().equalsIgnoreCase("CSM")) throw new ParsingException("Invalid CSM, doesn't start with the \"CSM(\" tag: " + csmString); do { String field = st.nextToken(); int separatorIndex = field.indexOf('/'); if (separatorIndex > 0) { String tag = field.substring(0, separatorIndex).toUpperCase(); String content = ""; if (separatorIndex < field.length()) content = field.substring(separatorIndex + 1); if (tag.equalsIgnoreCase("MCL")) csm.setMCL(content); else csm.addField(tag, content); } else throw new ParsingException("Invalid field, doesn't have a tag: " + field); } while (st.hasMoreTokens()); if (csm.getMCL() == null) throw new ParsingException("Invalid CSM, doesn't contain an MCL: " + csmString); return csm; } CryptographicServiceMessage(); CryptographicServiceMessage(String mcl); void setMCL(String mcl); String getMCL(); void addField(String tag, String content); String getFieldContent(String tag); @Override String toString(); @Override void dump(PrintStream p, String indent); static CryptographicServiceMessage parse(String csmString); static final String MCL_RSI; static final String MCL_KSM; static final String MCL_RSM; static final String MCL_ESM; static final String TAG_RCV; static final String TAG_ORG; static final String TAG_SVR; static final String TAG_KD; static final String TAG_CTP; static final String TAG_CTR; static final String TAG_ERF; }### Answer: @Test void testParse() throws Throwable { CryptographicServiceMessage result = CryptographicServiceMessage.parse("CSM(MCL/"); assertEquals("", result.getMCL()); } @Test void testParseThrowsNoSuchElementException() { thrown = assertThrows(NoSuchElementException.class, () -> CryptographicServiceMessage.parse("") ); assertNull(thrown.getMessage()); } @Test void testParseThrowsNoSuchElementException1() { thrown = assertThrows(NoSuchElementException.class, () -> CryptographicServiceMessage.parse("CSM") ); assertNull(thrown.getMessage()); } @Test void testParseThrowsNullPointerException() { thrown = assertThrows(NullPointerException.class, () -> CryptographicServiceMessage.parse(null) ); if (isJavaVersionAtMost(JAVA_14)) { assertNull(thrown.getMessage()); } else { assertEquals("Cannot invoke \"String.length()\" because \"str\" is null", thrown.getMessage()); } } @Test void testParseThrowsParsingException() { thrown = assertThrows(ParsingException.class, () -> CryptographicServiceMessage.parse("CSM(MCL") ); assertEquals("Invalid field, doesn't have a tag: MCL", thrown.getMessage()); } @Test void testParseThrowsParsingException1() { thrown = assertThrows(ParsingException.class, () -> CryptographicServiceMessage.parse("testCsmString") ); assertEquals("Invalid CSM, doesn't start with the \"CSM(\" tag: testCsmString" , thrown.getMessage() ); }
### Question: CryptographicServiceMessage implements Loggeable { @Override public String toString() { StringBuilder csm = new StringBuilder(); csm.append("CSM(MCL/"); csm.append(getMCL()); csm.append(" "); for (String tag : orderedTags) { csm.append(tag); csm.append("/"); csm.append(getFieldContent(tag)); csm.append(" "); } csm.append(")"); return csm.toString(); } CryptographicServiceMessage(); CryptographicServiceMessage(String mcl); void setMCL(String mcl); String getMCL(); void addField(String tag, String content); String getFieldContent(String tag); @Override String toString(); @Override void dump(PrintStream p, String indent); static CryptographicServiceMessage parse(String csmString); static final String MCL_RSI; static final String MCL_KSM; static final String MCL_RSM; static final String MCL_ESM; static final String TAG_RCV; static final String TAG_ORG; static final String TAG_SVR; static final String TAG_KD; static final String TAG_CTP; static final String TAG_CTR; static final String TAG_ERF; }### Answer: @Test void testToString() { instance.setMCL("testMcl"); String result = instance.toString(); assertEquals("CSM(MCL/testMcl )", result); }
### Question: EncryptedPIN implements Serializable, Loggeable { public String getAccountNumber () { return accountNumber; } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testConstructor() throws Throwable { EncryptedPIN encryptedPIN = new EncryptedPIN(); assertNull(encryptedPIN.getAccountNumber(), "encryptedPIN.getAccountNumber()"); } @Test public void testGetAccountNumber() throws Throwable { byte[] pinBlock = new byte[0]; String result = new EncryptedPIN(pinBlock, (byte) 0, "testEncryptedPINAccountNumber").getAccountNumber(); assertEquals("AccountNumbe", result, "result"); } @Test public void testGetAccountNumber1() throws Throwable { String result = new EncryptedPIN().getAccountNumber(); assertNull(result, "result"); }
### Question: EncryptedPIN implements Serializable, Loggeable { public void dump (PrintStream p, String indent) { String inner = indent + " "; p.print(indent + "<encrypted-pin"); p.print(" format=\"0" + getPINBlockFormat() + "\""); p.println(">"); p.println(inner + "<pin-block>" + ISOUtil.hexString(getPINBlock()) + "</pin-block>"); p.println(inner + "<account-number>" + getAccountNumber() + "</account-number>"); p.println(indent + "</encrypted-pin>"); } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testDump() throws Throwable { byte[] pinBlock = new byte[0]; PrintStream p = new PrintStream(new ByteArrayOutputStream(), true, "UTF-16BE"); new EncryptedPIN(pinBlock, (byte) 0, "testEncryptedPINAccountNumber").dump(p, "testEncryptedPINIndent"); assertTrue(true, "Test completed without Exception"); } @Test public void testDumpThrowsNullPointerException() throws Throwable { try { new EncryptedPIN().dump(null, "testEncryptedPINIndent"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.io.PrintStream.print(String)\" because \"p\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: EncryptedPIN implements Serializable, Loggeable { public static String extractAccountNumberPart (String accountNumber) { String accountNumberPart = null; try { accountNumberPart = ISOUtil.takeLastN(accountNumber, 13); accountNumberPart = ISOUtil.takeFirstN(accountNumberPart, 12); } catch(ISOException ignored) { } return accountNumberPart; } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testExtractAccountNumberPart() throws Throwable { String result = EncryptedPIN.extractAccountNumberPart("11Character"); assertEquals("0011Characte", result, "result"); } @Test public void testExtractAccountNumberPart1() throws Throwable { String result = EncryptedPIN.extractAccountNumberPart("13CharactersX"); assertEquals("13Characters", result, "result"); } @Test public void testExtractAccountNumberPart2() throws Throwable { String result = EncryptedPIN.extractAccountNumberPart("12Characters"); assertEquals("012Character", result, "result"); } @Test public void testExtractAccountNumberPartThrowsNullPointerException() throws Throwable { try { EncryptedPIN.extractAccountNumberPart(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.length()\" because \"s\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: EncryptedPIN implements Serializable, Loggeable { public byte[] getPINBlock () { return pinBlock; } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testGetPINBlock() throws Throwable { byte[] pinBlock = new byte[2]; EncryptedPIN encryptedPIN = new EncryptedPIN(pinBlock, (byte) 0, "testEncryptedPINAccountNumber"); byte[] pinBlock2 = new byte[3]; encryptedPIN.setPINBlock(pinBlock2); byte[] result = encryptedPIN.getPINBlock(); assertSame(pinBlock2, result, "result"); assertEquals((byte) 0, pinBlock2[0], "pinBlock2[0]"); }
### Question: EncryptedPIN implements Serializable, Loggeable { public byte getPINBlockFormat () { return this.pinBlockFormat; } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testGetPINBlockFormat() throws Throwable { byte[] pinBlock = new byte[2]; byte result = new EncryptedPIN(pinBlock, (byte) 100, "testEncryptedPINAccountNumber").getPINBlockFormat(); assertEquals((byte) 100, result, "result"); }
### Question: TLVList implements Serializable, Loggeable { public TLVMsg find(int tag) { tagToFind = tag; for (TLVMsg tlv : tags) { if (tlv.getTag() == tag) { indexLastOccurrence = tags.indexOf(tlv); return tlv; } } indexLastOccurrence = -1; return null; } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testFind() { instance.append(TEST_TAG1, new byte[1]); TLVMsg expected = instance.createTLVMsg(0x07, null); instance.append(expected); TLVMsg result = instance.find(0x07); assertSame(expected, result); } @Test public void testFind3() { TLVMsg result = instance.find(TEST_TAG1); assertNull(result); }
### Question: EncryptedPIN implements Serializable, Loggeable { public void setAccountNumber (String extractedAccountNumber) { if(extractedAccountNumber.length() != 12) throw new InvalidParameterException( "Extracted account number length should be 12, got '" +ISOUtil.protect(extractedAccountNumber) + "'" ); this.accountNumber = extractedAccountNumber; } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testSetAccountNumber() throws Throwable { byte[] pinBlock = new byte[3]; EncryptedPIN encryptedPIN = new EncryptedPIN(pinBlock, (byte) 0, "testEncryptedPINAccountNumber"); try { encryptedPIN.setAccountNumber("13CharactersX"); fail("Expected InvalidParameterException"); } catch (InvalidParameterException ignored) { } } @Test public void testSetAccountNumber1() throws Throwable { EncryptedPIN encryptedPIN = new EncryptedPIN("testEncryptedPINPinBlockHexString1", (byte) 0, "testEncryptedPINAccountNumber"); encryptedPIN.setAccountNumber("12Characters"); assertEquals("12Characters", encryptedPIN.accountNumber, "encryptedPIN.accountNumber"); } @Test public void testSetAccountNumberThrowsNullPointerException() throws Throwable { EncryptedPIN encryptedPIN = new EncryptedPIN("testEncryptedPINPinBlockHexString1", (byte) 0, "testEncryptedPINAccountNumber"); try { encryptedPIN.setAccountNumber(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.length()\" because \"extractedAccountNumber\" is null", ex.getMessage(), "ex.getMessage()"); } assertEquals("AccountNumbe", encryptedPIN.accountNumber, "encryptedPIN.accountNumber"); } }
### Question: EncryptedPIN implements Serializable, Loggeable { public void setPINBlock (byte[] pinBlock) { this.pinBlock = pinBlock; } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testSetPINBlock() throws Throwable { byte[] pinBlock = new byte[3]; EncryptedPIN encryptedPIN = new EncryptedPIN(pinBlock, (byte) 0, "testEncryptedPINAccountNumber"); byte[] pinBlock2 = new byte[0]; encryptedPIN.setPINBlock(pinBlock2); assertSame(pinBlock2, encryptedPIN.pinBlock, "encryptedPIN.pinBlock"); }
### Question: EncryptedPIN implements Serializable, Loggeable { public void setPINBlockFormat (byte pinBlockFormat) { this.pinBlockFormat = pinBlockFormat; } EncryptedPIN(); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber); EncryptedPIN(byte[] pinBlock, byte pinBlockFormat, String accountNumber, boolean extract); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber); EncryptedPIN(String pinBlockHexString, byte pinBlockFormat, String accountNumber, boolean extract); void dump(PrintStream p, String indent); void setPINBlock(byte[] pinBlock); byte[] getPINBlock(); void setPINBlockFormat(byte pinBlockFormat); byte getPINBlockFormat(); void setAccountNumber(String extractedAccountNumber); String getAccountNumber(); static String extractAccountNumberPart(String accountNumber); }### Answer: @Test public void testSetPINBlockFormat() throws Throwable { EncryptedPIN encryptedPIN = new EncryptedPIN("testEncryptedPINPinBlockHexString1", (byte) 0, "testEncryptedPINAccountNumber"); encryptedPIN.setPINBlockFormat((byte) 100); assertEquals((byte) 100, encryptedPIN.pinBlockFormat, "encryptedPIN.pinBlockFormat"); }
### Question: SecureKeyBlock extends SecureKey { @Override public void setKeyType(String keyType) { throw new UnsupportedOperationException( "Operation setKeyType() not allowed for " + SecureKeyBlock.class.getName() ); } protected SecureKeyBlock(); @Override void setKeyType(String keyType); @Override String getKeyType(); @Override void setKeyLength(short keyLength); @Override short getKeyLength(); @Override KeyScheme getScheme(); char getKeyBlockVersion(); int getKeyBlockLength(); KeyUsage getKeyUsage(); Algorithm getAlgorithm(); ModeOfUse getModeOfUse(); String getKeyVersion(); Exportability getExportability(); String getReserved(); Map<String, String> getOptionalHeaders(); byte[] getKeyBlockMAC(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testSetKeyType() { assertThrows(UnsupportedOperationException.class, () -> { instance.setKeyType(""); }); }
### Question: SecureKeyBlock extends SecureKey { @Override public String getKeyType() { throw new UnsupportedOperationException( "Operation getKeyType() not allowed for " + SecureKeyBlock.class.getName() ); } protected SecureKeyBlock(); @Override void setKeyType(String keyType); @Override String getKeyType(); @Override void setKeyLength(short keyLength); @Override short getKeyLength(); @Override KeyScheme getScheme(); char getKeyBlockVersion(); int getKeyBlockLength(); KeyUsage getKeyUsage(); Algorithm getAlgorithm(); ModeOfUse getModeOfUse(); String getKeyVersion(); Exportability getExportability(); String getReserved(); Map<String, String> getOptionalHeaders(); byte[] getKeyBlockMAC(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testGetKeyType() { assertThrows(UnsupportedOperationException.class, () -> { instance.getKeyType(); }); }
### Question: SecureKeyBlock extends SecureKey { @Override public void setKeyLength(short keyLength) { throw new UnsupportedOperationException( "Operation setKeyLength() not allowed for " + SecureKeyBlock.class.getName() ); } protected SecureKeyBlock(); @Override void setKeyType(String keyType); @Override String getKeyType(); @Override void setKeyLength(short keyLength); @Override short getKeyLength(); @Override KeyScheme getScheme(); char getKeyBlockVersion(); int getKeyBlockLength(); KeyUsage getKeyUsage(); Algorithm getAlgorithm(); ModeOfUse getModeOfUse(); String getKeyVersion(); Exportability getExportability(); String getReserved(); Map<String, String> getOptionalHeaders(); byte[] getKeyBlockMAC(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testSetKeyLength() { assertThrows(UnsupportedOperationException.class, () -> { instance.setKeyLength((short) 128); }); }
### Question: SecureKeyBlock extends SecureKey { @Override public short getKeyLength() { throw new UnsupportedOperationException( "Operation getKeyLength() not allowed for " + SecureKeyBlock.class.getName() ); } protected SecureKeyBlock(); @Override void setKeyType(String keyType); @Override String getKeyType(); @Override void setKeyLength(short keyLength); @Override short getKeyLength(); @Override KeyScheme getScheme(); char getKeyBlockVersion(); int getKeyBlockLength(); KeyUsage getKeyUsage(); Algorithm getAlgorithm(); ModeOfUse getModeOfUse(); String getKeyVersion(); Exportability getExportability(); String getReserved(); Map<String, String> getOptionalHeaders(); byte[] getKeyBlockMAC(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testGetKeyLength() { assertThrows(UnsupportedOperationException.class, () -> { instance.getKeyLength(); }); }
### Question: SecureKeyBlock extends SecureKey { @Override public KeyScheme getScheme() { return scheme; } protected SecureKeyBlock(); @Override void setKeyType(String keyType); @Override String getKeyType(); @Override void setKeyLength(short keyLength); @Override short getKeyLength(); @Override KeyScheme getScheme(); char getKeyBlockVersion(); int getKeyBlockLength(); KeyUsage getKeyUsage(); Algorithm getAlgorithm(); ModeOfUse getModeOfUse(); String getKeyVersion(); Exportability getExportability(); String getReserved(); Map<String, String> getOptionalHeaders(); byte[] getKeyBlockMAC(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testGetScheme() { KeyScheme expResult = null; KeyScheme result = instance.getScheme(); assertEquals(expResult, result); }
### Question: SecureKeyBlock extends SecureKey { public Map<String, String> getOptionalHeaders() { return Collections.unmodifiableMap(optionalHeaders); } protected SecureKeyBlock(); @Override void setKeyType(String keyType); @Override String getKeyType(); @Override void setKeyLength(short keyLength); @Override short getKeyLength(); @Override KeyScheme getScheme(); char getKeyBlockVersion(); int getKeyBlockLength(); KeyUsage getKeyUsage(); Algorithm getAlgorithm(); ModeOfUse getModeOfUse(); String getKeyVersion(); Exportability getExportability(); String getReserved(); Map<String, String> getOptionalHeaders(); byte[] getKeyBlockMAC(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testGetOptionalHeaders() { Map<String, String> expResult = new LinkedHashMap<>(); Map<String, String> result = instance.getOptionalHeaders(); assertEquals(expResult, result); }
### Question: ExtKeyUsage extends KeyUsage { public static KeyUsage valueOfByCode(String code) { KeyUsage ku = MAP.get(code); if (ku != null) return ku; return TR31MAP.get(code); } protected ExtKeyUsage(String code, String name); static KeyUsage valueOfByCode(String code); static Map<String, KeyUsage> entries(); final static KeyUsage DEK; final static KeyUsage ZEK; final static KeyUsage TEK; final static KeyUsage RSAPK; final static KeyUsage RSASK; final static KeyUsage RSASKICC; final static KeyUsage RSASKPIN; final static KeyUsage RSASKTLS; final static KeyUsage TMK; final static KeyUsage ZMK; final static KeyUsage HMACSHA1; final static KeyUsage HMACSHA224; final static KeyUsage HMACSHA256; final static KeyUsage HMACSHA384; final static KeyUsage HMACSHA512; final static KeyUsage TPK; final static KeyUsage ZPK; }### Answer: @Test public void testValueOfByCodeTEK() { KeyUsage ret = ExtKeyUsage.valueOfByCode("32"); assertEquals("32", ret.getCode()); assertEquals("Terminal Encryption Key", ret.getName()); assertSame(ExtKeyUsage.TEK, ret); } @Test public void testValueOfByCodeZPK() { KeyUsage ret = ExtKeyUsage.valueOfByCode("27"); assertEquals("27", ret.getCode()); assertEquals("Zone PIN Encryption Key", ret.getName()); assertSame(ExtKeyUsage.ZPK, ret); } @Test public void testValueOfByCodeKEK() { KeyUsage ret = ExtKeyUsage.valueOfByCode("K0"); assertEquals("K0", ret.getCode()); assertSame(KeyUsage.KEK, ret); }
### Question: ExtKeyUsage extends KeyUsage { public static Map<String, KeyUsage> entries() { Map ret = new LinkedHashMap(TR31MAP); ret.putAll(MAP); return Collections.unmodifiableMap(ret); } protected ExtKeyUsage(String code, String name); static KeyUsage valueOfByCode(String code); static Map<String, KeyUsage> entries(); final static KeyUsage DEK; final static KeyUsage ZEK; final static KeyUsage TEK; final static KeyUsage RSAPK; final static KeyUsage RSASK; final static KeyUsage RSASKICC; final static KeyUsage RSASKPIN; final static KeyUsage RSASKTLS; final static KeyUsage TMK; final static KeyUsage ZMK; final static KeyUsage HMACSHA1; final static KeyUsage HMACSHA224; final static KeyUsage HMACSHA256; final static KeyUsage HMACSHA384; final static KeyUsage HMACSHA512; final static KeyUsage TPK; final static KeyUsage ZPK; }### Answer: @Test public void testEntries() { Map<String, KeyUsage> ret = ExtKeyUsage.entries(); assertTrue(ret.containsKey("D0")); assertTrue(ret.containsKey("K0")); assertTrue(ret.containsKey("M0")); assertTrue(ret.containsKey("V0")); assertTrue(ret.containsKey("12")); assertTrue(ret.containsKey("15")); assertTrue(ret.containsKey("17")); }
### Question: ExtKeyUsage extends KeyUsage { static Map<String, KeyUsage> loadKeyUsagesFromClasspath(String resource) { Properties props = new Properties(); try (InputStream in = loadResourceAsStream(resource)) { props.load(in); return registerKeyUsages(props); } catch (IOException | NullPointerException ex) { return null; } } protected ExtKeyUsage(String code, String name); static KeyUsage valueOfByCode(String code); static Map<String, KeyUsage> entries(); final static KeyUsage DEK; final static KeyUsage ZEK; final static KeyUsage TEK; final static KeyUsage RSAPK; final static KeyUsage RSASK; final static KeyUsage RSASKICC; final static KeyUsage RSASKPIN; final static KeyUsage RSASKTLS; final static KeyUsage TMK; final static KeyUsage ZMK; final static KeyUsage HMACSHA1; final static KeyUsage HMACSHA224; final static KeyUsage HMACSHA256; final static KeyUsage HMACSHA384; final static KeyUsage HMACSHA512; final static KeyUsage TPK; final static KeyUsage ZPK; }### Answer: @Test public void testLoadPropertiesFromClasspath() { ExtKeyUsage.loadKeyUsagesFromClasspath(TEST_EXTERNAL_KEYUSAGES); }
### Question: SMException extends ISOException { protected String getTagName () { return "security-module-exception"; } SMException(); SMException(String s); SMException(Exception e); SMException(String s, Exception e); }### Answer: @Test public void testGetTagName() throws Throwable { SMException jCEHandlerException = new JCEHandlerException("testSMExceptions"); String result = jCEHandlerException.getTagName(); assertEquals("security-module-exception", result, "result"); }
### Question: KeySerialNumber implements Serializable, Loggeable { public String getBaseKeyID () { return baseKeyID; } KeySerialNumber(); KeySerialNumber(String baseKeyID, String deviceID, String transactionCounter); void setBaseKeyID(String baseKeyID); String getBaseKeyID(); void setDeviceID(String deviceID); String getDeviceID(); void setTransactionCounter(String transactionCounter); String getTransactionCounter(); void dump(PrintStream p, String indent); }### Answer: @Test public void testConstructor() throws Throwable { KeySerialNumber keySerialNumber = new KeySerialNumber(); assertNull(keySerialNumber.getBaseKeyID(), "keySerialNumber.getBaseKeyID()"); } @Test public void testGetBaseKeyID() throws Throwable { String result = new KeySerialNumber("testKeySerialNumberBaseKeyID", "testKeySerialNumberDeviceID", "testKeySerialNumberTransactionCounter").getBaseKeyID(); assertEquals("testKeySerialNumberBaseKeyID", result, "result"); }
### Question: TLVList implements Serializable, Loggeable { public int findIndex(int tag) { tagToFind = tag; for (TLVMsg tlv : tags) { if (tlv.getTag() == tag) { indexLastOccurrence = tags.indexOf(tlv); return indexLastOccurrence; } } indexLastOccurrence = -1; return -1; } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testFindIndex() { instance.append(TEST_TAG1, new byte[2]); instance.append(TEST_TAG2, new byte[2]); int result = instance.findIndex(TEST_TAG2); assertEquals(1, result); }
### Question: KeySerialNumber implements Serializable, Loggeable { public void dump (PrintStream p, String indent) { String inner = indent + " "; p.println(indent + "<key-serial-number>"); p.println(inner + "<base-key-id>" + getBaseKeyID() + "</base-key-id>"); p.println(inner + "<device-id>" + getDeviceID() + "</device-id>"); p.println(inner + "<transaction-counter>" + getTransactionCounter() + "</transaction-counter"); p.println(indent + "</key-serial-number>"); } KeySerialNumber(); KeySerialNumber(String baseKeyID, String deviceID, String transactionCounter); void setBaseKeyID(String baseKeyID); String getBaseKeyID(); void setDeviceID(String deviceID); String getDeviceID(); void setTransactionCounter(String transactionCounter); String getTransactionCounter(); void dump(PrintStream p, String indent); }### Answer: @Test public void testDump() throws Throwable { PrintStream p = new PrintStream(new ByteArrayOutputStream(), true, "UTF-8"); Object[] objects = new Object[1]; p.format("testKeySerialNumberParam1", objects); new KeySerialNumber("testKeySerialNumberBaseKeyID", "testKeySerialNumberDeviceID", "testKeySerialNumberTransactionCounter") .dump(p, "testKeySerialNumberIndent"); assertTrue(true, "Test completed without Exception"); } @Test public void testDumpThrowsNullPointerException() throws Throwable { try { new KeySerialNumber().dump(null, "testKeySerialNumberIndent"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.io.PrintStream.println(String)\" because \"p\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: KeySerialNumber implements Serializable, Loggeable { public String getDeviceID () { return deviceID; } KeySerialNumber(); KeySerialNumber(String baseKeyID, String deviceID, String transactionCounter); void setBaseKeyID(String baseKeyID); String getBaseKeyID(); void setDeviceID(String deviceID); String getDeviceID(); void setTransactionCounter(String transactionCounter); String getTransactionCounter(); void dump(PrintStream p, String indent); }### Answer: @Test public void testGetDeviceID() throws Throwable { String result = new KeySerialNumber("testKeySerialNumberBaseKeyID", "testKeySerialNumberDeviceID", "testKeySerialNumberTransactionCounter").getDeviceID(); assertEquals("testKeySerialNumberDeviceID", result, "result"); }
### Question: KeySerialNumber implements Serializable, Loggeable { public String getTransactionCounter () { return transactionCounter; } KeySerialNumber(); KeySerialNumber(String baseKeyID, String deviceID, String transactionCounter); void setBaseKeyID(String baseKeyID); String getBaseKeyID(); void setDeviceID(String deviceID); String getDeviceID(); void setTransactionCounter(String transactionCounter); String getTransactionCounter(); void dump(PrintStream p, String indent); }### Answer: @Test public void testGetTransactionCounter() throws Throwable { String result = new KeySerialNumber("testKeySerialNumberBaseKeyID", "testKeySerialNumberDeviceID", "testKeySerialNumberTransactionCounter").getTransactionCounter(); assertEquals("testKeySerialNumberTransactionCounter", result, "result"); } @Test public void testGetTransactionCounter1() throws Throwable { String result = new KeySerialNumber().getTransactionCounter(); assertNull(result, "result"); }
### Question: KeySerialNumber implements Serializable, Loggeable { public void setBaseKeyID (String baseKeyID) { this.baseKeyID = baseKeyID; } KeySerialNumber(); KeySerialNumber(String baseKeyID, String deviceID, String transactionCounter); void setBaseKeyID(String baseKeyID); String getBaseKeyID(); void setDeviceID(String deviceID); String getDeviceID(); void setTransactionCounter(String transactionCounter); String getTransactionCounter(); void dump(PrintStream p, String indent); }### Answer: @Test public void testSetBaseKeyID() throws Throwable { KeySerialNumber keySerialNumber = new KeySerialNumber("testKeySerialNumberBaseKeyID", "testKeySerialNumberDeviceID", "testKeySerialNumberTransactionCounter"); keySerialNumber.setBaseKeyID("testKeySerialNumberBaseKeyID1"); assertEquals("testKeySerialNumberBaseKeyID1", keySerialNumber.baseKeyID, "keySerialNumber.baseKeyID"); }
### Question: KeySerialNumber implements Serializable, Loggeable { public void setDeviceID (String deviceID) { this.deviceID = deviceID; } KeySerialNumber(); KeySerialNumber(String baseKeyID, String deviceID, String transactionCounter); void setBaseKeyID(String baseKeyID); String getBaseKeyID(); void setDeviceID(String deviceID); String getDeviceID(); void setTransactionCounter(String transactionCounter); String getTransactionCounter(); void dump(PrintStream p, String indent); }### Answer: @Test public void testSetDeviceID() throws Throwable { KeySerialNumber keySerialNumber = new KeySerialNumber("testKeySerialNumberBaseKeyID", "testKeySerialNumberDeviceID", "testKeySerialNumberTransactionCounter"); keySerialNumber.setDeviceID("testKeySerialNumberDeviceID1"); assertEquals("testKeySerialNumberDeviceID1", keySerialNumber.deviceID, "keySerialNumber.deviceID"); }
### Question: KeySerialNumber implements Serializable, Loggeable { public void setTransactionCounter (String transactionCounter) { this.transactionCounter = transactionCounter; } KeySerialNumber(); KeySerialNumber(String baseKeyID, String deviceID, String transactionCounter); void setBaseKeyID(String baseKeyID); String getBaseKeyID(); void setDeviceID(String deviceID); String getDeviceID(); void setTransactionCounter(String transactionCounter); String getTransactionCounter(); void dump(PrintStream p, String indent); }### Answer: @Test public void testSetTransactionCounter() throws Throwable { KeySerialNumber keySerialNumber = new KeySerialNumber("testKeySerialNumberBaseKeyID", "testKeySerialNumberDeviceID", "testKeySerialNumberTransactionCounter"); keySerialNumber.setTransactionCounter("testKeySerialNumberTransactionCounter1"); assertEquals("testKeySerialNumberTransactionCounter1", keySerialNumber.transactionCounter, "keySerialNumber.transactionCounter"); }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { @Override public Logger getLogger () { return logger; } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testGetLogger() throws Throwable { Logger logger = Logger.getLogger("testSimpleKeyFileName"); SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); simpleKeyFile.setLogger(logger, "testSimpleKeyFileRealm"); Logger result = simpleKeyFile.getLogger(); assertSame(logger, result, "result"); }
### Question: TLVList implements Serializable, Loggeable { public TLVMsg findNextTLV() throws IllegalStateException { if (tagToFind < 0) throw new IllegalStateException( "The initialization of the searched tag is required" ); for ( int i=indexLastOccurrence + 1 ; i < tags.size(); i++) { if (tags.get(i).getTag() == tagToFind) { indexLastOccurrence = i; return tags.get(i); } } return null; } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testFindNextTLV() { instance.findIndex(TEST_TAG1); instance.append(TEST_TAG3, new byte[0]); TLVMsg result = instance.findNextTLV(); assertNull(result); } @Test public void testFindNextTLVThrowsIllegalStateExeption2() { assertThrows(IllegalStateException.class, () -> { instance.findNextTLV(); }); }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { public String getProperty (String alias, String subName) throws SecureKeyStoreException { String key = alias + "." + subName; String value = props.getProperty(key); if (value == null) throw new SecureKeyStoreException("Key can't be retrieved. Can't get property: " + key); return value.trim(); } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testGetPropertyThrowsSecureKeyStoreException() throws Throwable { try { new SimpleKeyFile().getProperty("testSimpleKeyFileAlias", "testSimpleKeyFileSubName"); fail("Expected SecureKeyStoreException to be thrown"); } catch (SecureKeyStore.SecureKeyStoreException ex) { assertEquals("Key can't be retrieved. Can't get property: testSimpleKeyFileAlias.testSimpleKeyFileSubName", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested(), "ex.getNested()"); } }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { @Override public String getRealm () { return realm; } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testGetRealm() throws Throwable { String result = new SimpleKeyFile().getRealm(); assertNull(result, "result"); }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { public void init (String keyFileName) throws SecureKeyStoreException { file = new File(keyFileName); try { if (!file.exists()) file.createNewFile(); load(); } catch (Exception e) { throw new SecureKeyStoreException(e); } } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testInitThrowsNullPointerException() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); try { simpleKeyFile.init(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); assertNull(simpleKeyFile.file, "simpleKeyFile.file"); assertEquals(0, simpleKeyFile.props.size(), "simpleKeyFile.props.size()"); } } @Test public void testInitThrowsSecureKeyStoreException() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); try { simpleKeyFile.init("."); fail("Expected SecureKeyStoreException to be thrown"); } catch (SecureKeyStore.SecureKeyStoreException ex) { assertEquals(".", simpleKeyFile.file.getName(), "simpleKeyFile.file.getName()"); assertEquals(0, simpleKeyFile.props.size(), "simpleKeyFile.props.size()"); } }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { void load () throws SecureKeyStoreException { InputStream in; try { if (!file.canRead()) throw new SecureKeyStoreException("Can't read from file: " + file.getCanonicalPath()); in = new BufferedInputStream(new FileInputStream(file)); try { props.load(in); } finally { in.close(); } } catch (Exception e) { throw new SecureKeyStoreException(e); } } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testLoadThrowsSecureKeyStoreException() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); try { simpleKeyFile.load(); fail("Expected SecureKeyStoreException to be thrown"); } catch (SecureKeyStore.SecureKeyStoreException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"java.io.File.canRead()\" because \"this.file\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"java.io.File.canRead()\" because \"this.file\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } assertNull(simpleKeyFile.file, "simpleKeyFile.file"); assertEquals(0, simpleKeyFile.props.size(), "simpleKeyFile.props.size()"); } }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { @Override public void setConfiguration (Configuration cfg) throws ConfigurationException { try { init(cfg.get("key-file")); header = cfg.get("file-header", header); } catch (Exception e) { throw new ConfigurationException(e); } } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testSetConfigurationThrowsConfigurationException() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); Configuration cfg = new SimpleConfiguration(new Properties()); try { simpleKeyFile.setConfiguration(cfg); fail("Expected ConfigurationException to be thrown"); } catch (ConfigurationException ex) { assertEquals("", simpleKeyFile.file.getName(), "simpleKeyFile.file.getName()"); assertEquals("Key File", simpleKeyFile.header, "simpleKeyFile.header"); assertEquals(0, simpleKeyFile.props.size(), "simpleKeyFile.props.size()"); } }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { @Override public synchronized void setKey (String alias, SecureKey secureKey) throws SecureKeyStoreException { LogEvent evt = new LogEvent(this, "set-key"); evt.addMessage("alias", alias); evt.addMessage(secureKey); try { if (!(secureKey instanceof SecureDESKey)) throw new SecureKeyStoreException("Unsupported SecureKey class: " + secureKey.getClass().getName()); load(); setProperty(alias, "class", secureKey.getClass().getName()); setProperty(alias, "key", ISOUtil.hexString(secureKey.getKeyBytes())); setProperty(alias, "length", Short.toString(secureKey.getKeyLength())); setProperty(alias, "type", secureKey.getKeyType()); String keyCheckValueHexString = ISOUtil.hexString(((SecureDESKey)secureKey).getKeyCheckValue()); setProperty(alias, "checkvalue", keyCheckValueHexString); store(); } catch (Exception e) { evt.addMessage(e); throw e instanceof SecureKeyStoreException ? (SecureKeyStoreException) e : new SecureKeyStoreException(e); } finally { Logger.log(evt); } } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testSetKeyThrowsSecureKeyStoreException() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); try { simpleKeyFile.setKey("testSimpleKeyFileAlias", null); fail("Expected SecureKeyStoreException to be thrown"); } catch (SecureKeyStore.SecureKeyStoreException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"Object.getClass()\" because \"secureKey\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"Object.getClass()\" because \"secureKey\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } assertEquals(0, simpleKeyFile.props.size(), "simpleKeyFile.props.size()"); assertNull(simpleKeyFile.file, "simpleKeyFile.file"); } }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { @Override public void setLogger (Logger logger, String realm) { this.logger = logger; this.realm = realm; } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testSetLogger() throws Throwable { Logger logger = Logger.getLogger("testSimpleKeyFileName"); SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); simpleKeyFile.setLogger(logger, "testSimpleKeyFileRealm"); assertSame(logger, simpleKeyFile.logger, "simpleKeyFile.logger"); assertEquals("testSimpleKeyFileRealm", simpleKeyFile.realm, "simpleKeyFile.realm"); }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { public void setProperty (String alias, String subName, String value) { String key = alias + "." + subName; props.setProperty(key, value); } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testSetProperty() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); simpleKeyFile.setProperty("testSimpleKeyFileAlias", "testSimpleKeyFileSubName", "testSimpleKeyFileValue"); assertEquals(1, simpleKeyFile.props.size(), "simpleKeyFile.props.size()"); assertEquals("testSimpleKeyFileValue", simpleKeyFile.props.get("testSimpleKeyFileAlias.testSimpleKeyFileSubName"), "simpleKeyFile.props.get(\"testSimpleKeyFileAlias.testSimpleKeyFileSubName\")"); } @Test public void testSetPropertyThrowsNullPointerException() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); try { simpleKeyFile.setProperty("testSimpleKeyFileAlias", "testSimpleKeyFileSubName", null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); assertEquals(0, simpleKeyFile.props.size(), "simpleKeyFile.props.size()"); } }
### Question: SimpleKeyFile implements SecureKeyStore, Configurable, LogSource { void store () throws SecureKeyStoreException { FileOutputStream out; try { if (!file.canWrite()) throw new SecureKeyStoreException("Can't write to file: " + file.getCanonicalPath()); out = new FileOutputStream(file); props.store(out, header); out.flush(); out.close(); } catch (Exception e) { throw new SecureKeyStoreException(e); } } SimpleKeyFile(); SimpleKeyFile(String keyFileName); void init(String keyFileName); @Override void setLogger(Logger logger, String realm); @Override Logger getLogger(); @Override String getRealm(); @Override void setConfiguration(Configuration cfg); @Override synchronized SecureKey getKey(String alias); @Override synchronized void setKey(String alias, SecureKey secureKey); String getProperty(String alias, String subName); void setProperty(String alias, String subName, String value); @Override Map<String, SecureKey> getKeys(); }### Answer: @Test public void testStoreThrowsSecureKeyStoreException() throws Throwable { SimpleKeyFile simpleKeyFile = new SimpleKeyFile(); try { simpleKeyFile.store(); fail("Expected SecureKeyStoreException to be thrown"); } catch (SecureKeyStore.SecureKeyStoreException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"java.io.File.canWrite()\" because \"this.file\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"java.io.File.canWrite()\" because \"this.file\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } assertNull(simpleKeyFile.file, "simpleKeyFile.file"); } }
### Question: SecureDESKey extends SecureVariantKey { @Override public void dump (PrintStream p, String indent) { String inner = indent + " "; p.print(indent + "<secure-des-key"); p.print(" length=\"" + getKeyLength() + "\""); p.print(" type=\"" + keyType + "\""); p.print(" variant=\"" + getVariant() + "\""); p.print(" scheme=\"" + this.getScheme() + "\""); if (keyName != null) p.print(" name=\"" + keyName + "\""); p.println(">"); p.println(inner + "<data>" + ISOUtil.hexString(getKeyBytes()) + "</data>"); p.println(inner + "<check-value>" + ISOUtil.hexString(getKeyCheckValue()) + "</check-value>"); p.println(indent + "</secure-des-key>"); } SecureDESKey(); SecureDESKey(short keyLength, String keyType, byte variant, KeyScheme scheme, byte[] keyBytes, byte[] keyCheckValue); SecureDESKey(short keyLength, String keyType, byte[] keyBytes, byte[] keyCheckValue); SecureDESKey(short keyLength, String keyType, String keyHexString, String keyCheckValueHexString); SecureDESKey(short keyLength, String keyType, byte variant, KeyScheme scheme, String keyHexString, String keyCheckValueHexString); @Override byte getVariant(); @Override KeyScheme getScheme(); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testDump() throws Throwable { byte[] keyBytes = new byte[1]; PrintStream p = new PrintStream(new ByteArrayOutputStream()); new SecureDESKey(length, keyType, keyBytes, kcv).dump(p, "testIndent"); assertTrue(true, "Test completed without Exception"); } @Test public void testDumpThrowsNullPointerException() throws Throwable { assertThrows(NullPointerException.class, () -> { PrintStream p = new PrintStream(new ByteArrayOutputStream()); new SecureDESKey(length, keyType, null, kcv1).dump(p, ""); }); } @Test public void testDumpThrowsNullPointerException1() throws Throwable { assertThrows(NullPointerException.class, () -> { byte[] keyBytes = new byte[2]; new SecureDESKey(length, keyType, keyBytes, kcv).dump(null, ""); }); }
### Question: TLVList implements Serializable, Loggeable { public TLVMsg index(int index) throws IndexOutOfBoundsException { return tags.get(index); } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testIndex() { TLVMsg expected = instance.createTLVMsg(TEST_TAG1, null); instance.append(expected); TLVMsg result = instance.index(0); assertSame(expected, result); } @Test public void testIndexThrowsIndexOutOfBounds() { assertThrows(IndexOutOfBoundsException.class, () -> { instance.index(TEST_TAG1); }); }
### Question: TLVList implements Serializable, Loggeable { public byte[] pack() { ByteBuffer buffer = ByteBuffer.allocate(516); for (TLVMsg tlv : tags) buffer.put(tlv.getTLV()); byte[] b = new byte[buffer.position()]; buffer.flip(); buffer.get(b); return b; } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testPack() { byte[] result = instance.pack(); assertEquals(0, result.length); }
### Question: TLVList implements Serializable, Loggeable { public void unpack(byte[] buf) throws IllegalArgumentException { unpack(buf, 0); } TLVList(); void unpack(byte[] buf); List<TLVMsg> getTags(); Enumeration<TLVMsg> elements(); void unpack(byte[] buf, int offset); void append(TLVMsg tlv); TLVList append(int tag, byte[] value); TLVList append(int tag, String value); void deleteByIndex(int index); void deleteByTag(int tag); TLVMsg find(int tag); int findIndex(int tag); TLVMsg findNextTLV(); TLVMsg index(int index); byte[] pack(); String getString(int tag); byte[] getValue(int tag); boolean hasTag(int tag); @Override void dump(PrintStream p, String indent); }### Answer: @Test public void testUnpack() { byte[] buf = ISOUtil.hex2byte("030100"); instance.unpack(buf, 0); assertFalse(instance.getTags().isEmpty()); TLVMsg tm = instance.index(0); assertEquals(0x03, tm.getTag()); assertArrayEquals(ISOUtil.hex2byte("00"), tm.getValue()); } @Test public void testUnpackFixeTagOneWith0x00Padding1() { assertThrows(IllegalArgumentException.class, () -> { instance = BUILDER_FT1.build(); instance.unpack(ISOUtil.hex2byte("000003112233")); }); } @Test public void testUnpackThrowsNullPointerException() { assertThrows(NullPointerException.class, () -> { instance.unpack(null, 100); }); } @Test public void testUnpackThrowsNullPointerException1() { assertThrows(NullPointerException.class, () -> { instance.unpack(null); }); }
### Question: JCEHandler { public byte[] decryptData(byte[] encryptedData, Key key) throws JCEHandlerException { return doCryptStuff(encryptedData, key, Cipher.DECRYPT_MODE); } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testDecryptDataThrowsNullPointerException() throws Throwable { try { new JCEHandler((Provider) null).decryptData("testString".getBytes(), null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.security.Key.getAlgorithm()\" because \"key\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: JCEHandler { public Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity) throws JCEHandlerException { byte[] clearKeyBytes = doCryptStuff(encryptedDESKey, encryptingKey, Cipher.DECRYPT_MODE); if (checkParity && !Util.isDESParityAdjusted(clearKeyBytes)) { throw new JCEHandlerException("Parity not adjusted"); } return formDESKey(keyLength, clearKeyBytes); } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testDecryptDESKeyThrowsNullPointerException() throws Throwable { byte[] encryptedDESKey = new byte[2]; try { new JCEHandler((Provider) null).decryptDESKey((short) 100, encryptedDESKey, null, true); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.security.Key.getAlgorithm()\" because \"key\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: JCEHandler { byte[] doCryptStuff(byte[] data, Key key, int direction) throws JCEHandlerException { return doCryptStuff(data, key, direction, CipherMode.ECB, null); } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testDoCryptStuffThrowsJCEHandlerException() throws Throwable { jCEHandler = new JCEHandler((Provider) null); byte[] bytes = new byte[1]; Key key = new SecretKeySpec(bytes, "testJCEHandlerParam2"); byte[] data = new byte[3]; try { jCEHandler.doCryptStuff(data, key, 100); fail("Expected JCEHandlerException to be thrown"); } catch (JCEHandlerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } assertEquals("testJCEHandlerParam2", key.getAlgorithm(), "(SecretKeySpec) key.getAlgorithm()"); } } @Test public void testDoCryptStuffThrowsNullPointerException() throws Throwable { byte[] data = new byte[4]; try { jCEHandler.doCryptStuff(data, null, 100); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.security.Key.getAlgorithm()\" because \"key\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: JCEHandler { public byte[] encryptData(byte[] data, Key key) throws JCEHandlerException { return doCryptStuff(data, key, Cipher.ENCRYPT_MODE); } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testEncryptDataThrowsNullPointerException() throws Throwable { byte[] data = new byte[1]; try { new JCEHandler((Provider) null).encryptData(data, null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.security.Key.getAlgorithm()\" because \"key\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: JCEHandler { public byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey) throws JCEHandlerException { byte[] clearKeyBytes = extractDESKeyMaterial(keyLength, clearDESKey); Util.adjustDESParity(clearKeyBytes); return doCryptStuff(clearKeyBytes, encryptingKey, Cipher.ENCRYPT_MODE); } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testEncryptDESKeyThrowsArrayIndexOutOfBoundsException() throws Throwable { byte[] bytes = new byte[3]; Key clearDESKey = new SecretKeySpec(bytes, 0, 1, "DESde"); byte[] bytes2 = new byte[1]; Key encryptingKey = new SecretKeySpec(bytes2, "testJCEHandlerParam2"); try { new JCEHandler((Provider) null).encryptDESKey((short) 64, clearDESKey, encryptingKey); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { if (isJavaVersionAtMost(JAVA_10)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("arraycopy: last source index 8 out of bounds for byte[1]", ex.getMessage(), "ex.getMessage()"); } assertEquals("DESde", clearDESKey.getAlgorithm(), "(SecretKeySpec) clearDESKey.getAlgorithm()"); assertEquals("testJCEHandlerParam2", encryptingKey.getAlgorithm(), "(SecretKeySpec) encryptingKey.getAlgorithm()"); } } @Test public void testEncryptDESKeyThrowsNullPointerException() throws Throwable { byte[] bytes = new byte[1]; Key encryptingKey = new SecretKeySpec(bytes, "testJCEHandlerParam2"); try { new JCEHandler((Provider) null).encryptDESKey((short) 100, null, encryptingKey); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.security.Key.getAlgorithm()\" because \"clearDESKey\" is null", ex.getMessage(), "ex.getMessage()"); } assertEquals("testJCEHandlerParam2", encryptingKey.getAlgorithm(), "(SecretKeySpec) encryptingKey.getAlgorithm()"); } }
### Question: JCEHandler { protected byte[] extractDESKeyMaterial(short keyLength, Key clearDESKey) throws JCEHandlerException { String keyAlg = clearDESKey.getAlgorithm(); String keyFormat = clearDESKey.getFormat(); if (keyFormat.compareTo("RAW") != 0) { throw new JCEHandlerException("Unsupported DES key encoding format: " + keyFormat); } if (!keyAlg.startsWith(ALG_DES)) { throw new JCEHandlerException("Unsupported key algorithm: " + keyAlg); } byte[] clearKeyBytes = clearDESKey.getEncoded(); clearKeyBytes = ISOUtil.trim(clearKeyBytes, getBytesLength(keyLength)); return clearKeyBytes; } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testExtractDESKeyMaterialThrowsJCEHandlerException1() throws Throwable { byte[] bytes = new byte[1]; Key clearDESKey = new SecretKeySpec(bytes, "testJCEHandlerParam2"); try { jCEHandler.extractDESKeyMaterial((short) 100, clearDESKey); fail("Expected JCEHandlerException to be thrown"); } catch (JCEHandlerException ex) { assertEquals("Unsupported key algorithm: testJCEHandlerParam2", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested(), "ex.getNested()"); assertEquals("testJCEHandlerParam2", clearDESKey.getAlgorithm(), "(SecretKeySpec) clearDESKey.getAlgorithm()"); } } @Test public void testExtractDESKeyMaterialThrowsNullPointerException() throws Throwable { try { jCEHandler.extractDESKeyMaterial((short) 100, null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.security.Key.getAlgorithm()\" because \"clearDESKey\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: JCEHandler { protected Key formDESKey(short keyLength, byte[] clearKeyBytes) throws JCEHandlerException { Key key = null; switch (keyLength) { case SMAdapter.LENGTH_DES: { key = new SecretKeySpec(clearKeyBytes, ALG_DES); } break; case SMAdapter.LENGTH_DES3_2KEY: { clearKeyBytes = ISOUtil.concat(clearKeyBytes, 0, getBytesLength(SMAdapter.LENGTH_DES3_2KEY), clearKeyBytes, 0, getBytesLength(SMAdapter.LENGTH_DES)); } case SMAdapter.LENGTH_DES3_3KEY: { key = new SecretKeySpec(clearKeyBytes, ALG_TRIPLE_DES); } } if (key == null) throw new JCEHandlerException("Unsupported DES key length: " + keyLength + " bits"); return key; } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testFormDESKey() throws Throwable { byte[] clearKeyBytes = new byte[4]; SecretKeySpec result = (SecretKeySpec) jCEHandler.formDESKey((short) 64, clearKeyBytes); assertEquals("DES", result.getAlgorithm(), "result.getAlgorithm()"); } @Test public void testFormDESKey1() throws Throwable { byte[] clearKeyBytes = new byte[1]; SecretKeySpec result = (SecretKeySpec) jCEHandler.formDESKey((short) 192, clearKeyBytes); assertEquals("DESede", result.getAlgorithm(), "result.getAlgorithm()"); } @Test public void testFormDESKeyThrowsArrayIndexOutOfBoundsException() throws Throwable { byte[] clearKeyBytes = new byte[1]; try { jCEHandler.formDESKey((short) 128, clearKeyBytes); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { if (isJavaVersionAtMost(JAVA_10)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("arraycopy: last source index 16 out of bounds for byte[1]", ex.getMessage(), "ex.getMessage()"); } } } @Test public void testFormDESKeyThrowsIllegalArgumentException() throws Throwable { byte[] clearKeyBytes = new byte[0]; try { jCEHandler.formDESKey((short) 192, clearKeyBytes); fail("Expected IllegalArgumentException to be thrown"); } catch (IllegalArgumentException ex) { assertEquals("Empty key", ex.getMessage(), "ex.getMessage()"); } } @Test public void testFormDESKeyThrowsIllegalArgumentException1() throws Throwable { byte[] clearKeyBytes = new byte[0]; try { jCEHandler.formDESKey((short) 64, clearKeyBytes); fail("Expected IllegalArgumentException to be thrown"); } catch (IllegalArgumentException ex) { assertEquals("Empty key", ex.getMessage(), "ex.getMessage()"); } } @Test public void testFormDESKeyThrowsJCEHandlerException() throws Throwable { byte[] clearKeyBytes = new byte[1]; try { jCEHandler.formDESKey((short) 100, clearKeyBytes); fail("Expected JCEHandlerException to be thrown"); } catch (JCEHandlerException ex) { assertEquals("Unsupported DES key length: 100 bits", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested(), "ex.getNested()"); } }
### Question: JCEHandler { public Key generateDESKey(short keyLength) throws JCEHandlerException { Key generatedClearKey = null; try { KeyGenerator k1; if (keyLength > SMAdapter.LENGTH_DES) { k1 = KeyGenerator.getInstance(ALG_TRIPLE_DES, provider.getName()); } else { k1 = KeyGenerator.getInstance(ALG_DES, provider.getName()); } generatedClearKey = k1.generateKey(); byte[] clearKeyBytes = extractDESKeyMaterial(keyLength, generatedClearKey); Util.adjustDESParity(clearKeyBytes); generatedClearKey = formDESKey(keyLength, clearKeyBytes); } catch (Exception e) { if (e instanceof JCEHandlerException) throw (JCEHandlerException) e; else throw new JCEHandlerException(e); } return generatedClearKey; } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testGenerateDESKeyThrowsJCEHandlerException() throws Throwable { try { new JCEHandler((Provider) null).generateDESKey((short) 63); fail("Expected JCEHandlerException to be thrown"); } catch (JCEHandlerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testGenerateDESKeyThrowsJCEHandlerException1() throws Throwable { try { new JCEHandler((Provider) null).generateDESKey((short) 64); fail("Expected JCEHandlerException to be thrown"); } catch (JCEHandlerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testGenerateDESKeyThrowsJCEHandlerException2() throws Throwable { try { new JCEHandler((Provider) null).generateDESKey((short) 65); fail("Expected JCEHandlerException to be thrown"); } catch (JCEHandlerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"java.security.Provider.getName()\" because \"this.provider\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } }
### Question: JCEHandler { int getBytesLength(short keyLength) throws JCEHandlerException { int bytesLength = 0; switch (keyLength) { case SMAdapter.LENGTH_DES: bytesLength = 8; break; case SMAdapter.LENGTH_DES3_2KEY: bytesLength = 16; break; case SMAdapter.LENGTH_DES3_3KEY: bytesLength = 24; break; default: throw new JCEHandlerException("Unsupported key length: " + keyLength + " bits"); } return bytesLength; } JCEHandler(String jceProviderClassName); JCEHandler(Provider provider); Key generateDESKey(short keyLength); byte[] encryptDESKey(short keyLength, Key clearDESKey, Key encryptingKey); Key decryptDESKey(short keyLength, byte[] encryptedDESKey, Key encryptingKey, boolean checkParity); byte[] encryptData(byte[] data, Key key); byte[] decryptData(byte[] encryptedData, Key key); byte[] encryptDataCBC(byte[] data, Key key, byte[] iv); byte[] decryptDataCBC(byte[] encryptedData, Key key, byte[] iv); byte[] generateMAC(byte[] data, Key kd, String macAlgorithm); }### Answer: @Test public void testGetBytesLength() throws Throwable { jCEHandler.getBytesLength((short) 128); assertTrue(true, "Test completed without Exception"); } @Test public void testGetBytesLength1() throws Throwable { jCEHandler.getBytesLength((short) 192); assertTrue(true, "Test completed without Exception"); } @Test public void testGetBytesLength2() throws Throwable { int result = jCEHandler.getBytesLength((short) 64); assertEquals(8, result, "result"); } @Test public void testGetBytesLengthThrowsJCEHandlerException() throws Throwable { try { jCEHandler.getBytesLength((short) 100); fail("Expected JCEHandlerException to be thrown"); } catch (JCEHandlerException ex) { assertEquals("Unsupported key length: 100 bits", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested(), "ex.getNested()"); } }
### Question: BERTLVPackager extends GenericPackager { @Override public byte[] pack(ISOComponent m) throws ISOException { return pack(m, false, getFirstField(), m.getMaxField()); } BERTLVPackager(); @Override byte[] pack(ISOComponent m); byte[] pack(ISOComponent m, boolean nested, int startIdx, int endIdx); @Override int unpack(ISOComponent m, byte[] b); int unpack(ISOComponent m, byte[] b, boolean nested); @Override void unpack(ISOComponent m, InputStream in); }### Answer: @Test public void testZeroLength() throws ISOException { BERTLVPackager p = new BERTLVAsciiHexPackager(); ISOTaggedField t = new ISOTaggedField( EMVStandardTagType.APPLICATION_FILE_LOCATOR_0x94.getTagNumberHex(), new ISOField(0, "")); t.setFieldNumber(1); ISOMsg m = new ISOMsg(55); m.set(t); byte[] b = p.pack(m, true, 1, 1); assertArrayEquals(ISOUtil.hex2byte("39343030"), b, ISOUtil.hexString(b)); }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { protected synchronized void checkRetryTask () { if (retryTask == null) { retryTask = new RetryTask(); new Thread(retryTask).start(); } } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testCheckRetryTask() throws Throwable { transactionManager.checkRetryTask(); transactionManager.checkRetryTask(); assertNotNull(transactionManager.retryTask, "transactionManager.retryTask"); } @Test public void testCheckRetryTask1() throws Throwable { transactionManager.checkRetryTask(); assertNotNull(transactionManager.retryTask, "transactionManager.retryTask"); }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { protected void checkTail () { Object lock = sp.in (tailLock); while (tailDone()) { tail++; } syncTail (); sp.out(tailLock, lock); } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testCheckTailThrowsNullPointerException() throws Throwable { try { transactionManager.checkTail(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.in(Object)\" because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(transactionManager.sp, "transactionManager.sp"); assertEquals(0L, transactionManager.tail, "transactionManager.tail"); assertNull(transactionManager.psp, "transactionManager.psp"); } }
### Question: BERTLVPackager extends GenericPackager { @Override public int unpack(ISOComponent m, byte[] b) throws ISOException { try { return unpack(m, b, false); } catch (RuntimeException e) { throw new ISOException(e); } } BERTLVPackager(); @Override byte[] pack(ISOComponent m); byte[] pack(ISOComponent m, boolean nested, int startIdx, int endIdx); @Override int unpack(ISOComponent m, byte[] b); int unpack(ISOComponent m, byte[] b, boolean nested); @Override void unpack(ISOComponent m, InputStream in); }### Answer: @Test public void testUnpackingZeroLength() { try { BERTLVPackager p = new BERTLVBinaryPackager(); p.setFieldPackager(new ISOFieldPackager[]{new IFA_TTLLBINARY()}); ISOMsg m = new ISOMsg(55); p.unpack(m, ISOUtil.hex2byte("9F3400")); } catch (ISOException e) { fail("Unexpected java.lang.ArithmeticException: divide by zero", e); } } @Test public void testUnpackingDate() { try { BERTLVPackager p = new BERTLVBinaryPackager(); p.setFieldPackager(new ISOFieldPackager[]{new IFA_TTLLBINARY()}); ISOMsg m = new ISOMsg(55); p.unpack(m, ISOUtil.hex2byte("9A03020618")); assertEquals("020618", m.getComponent("1").getValue()); } catch (ISOException e) { fail("Unexpected exception", e); } }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { @Override public long getHead () { return head; } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testGetHead() throws Throwable { long result = new TransactionManager().getHead(); assertEquals(0L, result, "result"); }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { protected String getKey (String prefix, long id) { StringBuilder sb = new StringBuilder (getName()); sb.append ('.'); sb.append (prefix); sb.append (Long.toString (id)); return sb.toString (); } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testGetKeyThrowsNullPointerException() throws Throwable { try { transactionManager.getKey(null, 100L); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.length()\" because \"str\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { @Override public int getOutstandingTransactions() { if (iisp instanceof LocalSpace) return ((LocalSpace) iisp).size(queue); return -1; } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testGetOutstandingTransactions() throws Throwable { int result = new TransactionManager().getOutstandingTransactions(); assertEquals(-1, result, "result"); }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { protected List<TransactionParticipant> getParticipants (String groupName) { List<TransactionParticipant> participants = groups.get (groupName); if (participants == null) { participants = new ArrayList(); } return participants; } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testGetParticipantsThrowsNullPointerException() throws Throwable { try { transactionManager.getParticipants("testTransactionManagerGroupName"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.util.Map.get(Object)\" because \"this.groups\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(transactionManager.groups, "transactionManager.groups"); } }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { @Override public long getTail () { return tail; } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testGetTail() throws Throwable { long result = new TransactionManager().getTail(); assertEquals(0L, result, "result"); }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { protected long initCounter (String name, long defValue) { Long L = (Long) psp.rdp (name); if (L == null) { L = defValue; psp.out (name, L); } return L; } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testInitCounterThrowsNullPointerException() throws Throwable { try { transactionManager.initCounter("testTransactionManagerName", 100L); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.rdp(Object)\" because \"this.psp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(transactionManager.psp, "transactionManager.psp"); } }
### Question: TransactionManager extends QBeanSupport implements Runnable, TransactionConstants, TransactionManagerMBean, Loggeable, MetricsProvider { @Override public void initService () throws ConfigurationException { queue = cfg.get ("queue", null); if (queue == null) throw new ConfigurationException ("queue property not specified"); sp = SpaceFactory.getSpace (cfg.get ("space")); isp = SpaceFactory.getSpace (cfg.get ("input-space", cfg.get ("space"))); if (isp == sp) iisp = isp; else { iisp = sp; } psp = SpaceFactory.getSpace (cfg.get ("persistent-space", this.toString())); tail = initCounter (TAIL, cfg.getLong ("initial-tail", 1)); head = Math.max (initCounter (HEAD, tail), tail); initTailLock (); groups = new HashMap<>(); initParticipants (getPersist()); initStatusListeners (getPersist()); } @Override void initService(); @Override void startService(); @Override void stopService(); void queue(Serializable context); void push(Serializable context); @SuppressWarnings("unused") String getQueueName(); Space getSpace(); Space getInputSpace(); Space getPersistentSpace(); @Override void run(); @Override long getTail(); @Override long getHead(); long getInTransit(); @Override void setConfiguration(Configuration cfg); void addListener(TransactionStatusListener l); void removeListener(TransactionStatusListener l); TPS getTPS(); @Override String getTPSAsString(); @Override float getTPSAvg(); @Override int getTPSPeak(); @Override Date getTPSPeakWhen(); @Override long getTPSElapsed(); @Override void resetTPS(); @Override Metrics getMetrics(); @Override void dump(PrintStream ps, String indent); TransactionParticipant createParticipant(Element e); @Override int getOutstandingTransactions(); @Override void setDebug(boolean debug); @Override boolean getDebugContext(); @Override void setDebugContext(boolean debugContext); @Override boolean getDebug(); @Override int getActiveSessions(); int getPausedCounter(); int getActiveTransactions(); int getMaxSessions(); static Serializable getSerializable(); static T getContext(); static Long getId(); static final String HEAD; static final String TAIL; static final String CONTEXT; static final String STATE; static final String GROUPS; static final String TAILLOCK; static final String RETRY_QUEUE; static final Integer PREPARING; static final Integer COMMITTING; static final Integer DONE; static final String DEFAULT_GROUP; static final long MAX_PARTICIPANTS; static final long MAX_WAIT; static final long TIMER_PURGE_INTERVAL; }### Answer: @Test public void testInitServiceThrowsNullPointerException() throws Throwable { try { transactionManager.initService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.core.Configuration.get(String, String)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(transactionManager.queue, "transactionManager.queue"); assertNull(transactionManager.getConfiguration(), "transactionManager.getConfiguration()"); assertEquals(0L, transactionManager.tail, "transactionManager.tail"); assertTrue(transactionManager.isModified(), "transactionManager.isModified()"); assertNull(transactionManager.sp, "transactionManager.sp"); assertNull(transactionManager.psp, "transactionManager.psp"); assertEquals(0L, transactionManager.head, "transactionManager.head"); assertNull(transactionManager.groups, "transactionManager.groups"); assertNull(transactionManager.tailLock, "transactionManager.tailLock"); } }