Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: FilterLogListener implements LogListener,Configurable { @Override public synchronized LogEvent log(LogEvent ev) { if (p != null && permitLogging(ev.getTag())) { Date d = new Date(); p.println( "<log realm=\"" + ev.getRealm() + "\" at=\"" + d.toString() + "." + d.getTime() % 1000 + "\">" ); ev.dump(p, " "); p.println("</log>"); p.flush(); } return ev; } FilterLogListener(); FilterLogListener(PrintStream p); @Override void setConfiguration(Configuration cfg); synchronized void setPrintStream(PrintStream p); synchronized void close(); String getPriority(); void setPriority(String priority); boolean permitLogging(String tagLevel); @Override synchronized LogEvent log(LogEvent ev); }### Answer: @Test public void testLog() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(); filterLogListener.close(); LogEvent result = filterLogListener.log(null); assertNull(result, "result"); } @Test public void testLog1() throws Throwable { LogEvent ev = new LogEvent(new BASE24TCPChannel(), "testFilterLogListenerTag", ""); FilterLogListener filterLogListener = new FilterLogListener(); LogEvent result = filterLogListener.log(ev); assertSame(ev, result, "result"); assertNotNull(filterLogListener.p, "filterLogListener.p"); }
### Question: FilterLogListener implements LogListener,Configurable { public boolean permitLogging(String tagLevel) { Integer i = LEVELS.get(tagLevel); if (i == null) i = LEVELS.get(Log.INFO); Integer j = LEVELS.get(priority); return i >= j; } FilterLogListener(); FilterLogListener(PrintStream p); @Override void setConfiguration(Configuration cfg); synchronized void setPrintStream(PrintStream p); synchronized void close(); String getPriority(); void setPriority(String priority); boolean permitLogging(String tagLevel); @Override synchronized LogEvent log(LogEvent ev); }### Answer: @Test public void testPermitLogging() throws Throwable { boolean result = new FilterLogListener().permitLogging("info"); assertTrue(result, "result"); } @Test public void testPermitLogging1() throws Throwable { boolean result = new FilterLogListener().permitLogging("trace"); assertFalse(result, "result"); } @Test public void testPermitLogging3() throws Throwable { boolean result = new FilterLogListener().permitLogging("testFilterLogListenerTagLevel"); assertTrue(result, "result"); } @Test public void testPermitLoggingThrowsNullPointerException() throws Throwable { try { new FilterLogListener().permitLogging(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: FilterLogListener implements LogListener,Configurable { @Override public void setConfiguration (Configuration cfg) throws ConfigurationException { try { String log_priority = cfg.get("priority"); if ( log_priority != null && !log_priority.trim().equals("") && LEVELS.containsKey(log_priority) ) { priority = log_priority; } } catch (Exception e) { throw new ConfigurationException (e); } } FilterLogListener(); FilterLogListener(PrintStream p); @Override void setConfiguration(Configuration cfg); synchronized void setPrintStream(PrintStream p); synchronized void close(); String getPriority(); void setPriority(String priority); boolean permitLogging(String tagLevel); @Override synchronized LogEvent log(LogEvent ev); }### Answer: @Test public void testSetConfiguration() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(); Configuration cfg = new SimpleConfiguration(); filterLogListener.setConfiguration(cfg); assertEquals("info", filterLogListener.getPriority(), "filterLogListener.getPriority()"); }
### Question: FilterLogListener implements LogListener,Configurable { public synchronized void setPrintStream(PrintStream p) { this.p = p; } FilterLogListener(); FilterLogListener(PrintStream p); @Override void setConfiguration(Configuration cfg); synchronized void setPrintStream(PrintStream p); synchronized void close(); String getPriority(); void setPriority(String priority); boolean permitLogging(String tagLevel); @Override synchronized LogEvent log(LogEvent ev); }### Answer: @Test public void testSetPrintStream() throws Throwable { PrintStream p = new PrintStream(new ByteArrayOutputStream()); FilterLogListener filterLogListener = new FilterLogListener(); filterLogListener.setPrintStream(p); assertSame(p, filterLogListener.p, "filterLogListener.p"); }
### Question: FilterLogListener implements LogListener,Configurable { public void setPriority(String priority) { this.priority = priority; } FilterLogListener(); FilterLogListener(PrintStream p); @Override void setConfiguration(Configuration cfg); synchronized void setPrintStream(PrintStream p); synchronized void close(); String getPriority(); void setPriority(String priority); boolean permitLogging(String tagLevel); @Override synchronized LogEvent log(LogEvent ev); }### Answer: @Test public void testSetPriority() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(new PrintStream(new ByteArrayOutputStream(), true)); filterLogListener.setPriority("testFilterLogListenerPriority"); assertEquals("testFilterLogListenerPriority", filterLogListener.getPriority(), "filterLogListener.getPriority()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public byte[] getHeader () { return header; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testGetHeader() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); byte[] h = new byte[2]; fSDMsg.setHeader(h); byte[] result = fSDMsg.getHeader(); assertSame(h, result, "result"); assertEquals((byte) 0, h[0], "h[0]"); }
### Question: FSDMsg implements Loggeable, Cloneable { public String getHexHeader () { return header != null ? ISOUtil.hexString (header).substring (2) : ""; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testGetHexHeader() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); byte[] h = new byte[1]; fSDMsg.setHeader(h); String result = fSDMsg.getHexHeader(); assertEquals("", result, "result"); } @Test public void testGetHexHeader1() throws Throwable { String result = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema").getHexHeader(); assertEquals("", result, "result"); }
### Question: FSDMsg implements Loggeable, Cloneable { public Map getMap () { return fields; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @SuppressWarnings("unchecked") @Test public void testGetMap() throws Throwable { LinkedHashMap result = (LinkedHashMap) new FSDMsg("testFSDMsgBasePath").getMap(); assertEquals(0, result.size(), "result.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public void set (String name, String value) { if (value != null) fields.put (name, value); else fields.remove (name); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testSet() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.set("testFSDMsgName", null); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public void setHeader (byte[] h) { this.header = h; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testSetHeader() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); byte[] h = new byte[2]; fSDMsg.setHeader(h); assertSame(h, fSDMsg.header, "fSDMsg.header"); }
### Question: FSDMsg implements Loggeable, Cloneable { public void setSeparator(String separatorName, char separator) { separators.put(separatorName, separator); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testSetSeparator() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.setSeparator("testFSDMsgSeparatorName", ' '); assertEquals(Character.valueOf(' '), fSDMsg.separators.get("testFSDMsgSeparatorName"), "fSDMsg.separators.get(\"testFSDMsgSeparatorName\")"); }
### Question: NameRegistrar implements Loggeable { public static NameRegistrar getInstance() { return instance; } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testGetInstance() throws Throwable { NameRegistrar result = NameRegistrar.getInstance(); assertThat(result, is(sameInstance(NameRegistrar.getInstance()))); }
### Question: NameRegistrar implements Loggeable { public static <T> T get(String key) throws NotFoundException { @SuppressWarnings("unchecked") T obj = (T) sp.rdp(key); if (obj == null) { throw new NotFoundException(key); } return obj; } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testGet() throws Exception { String value = NameRegistrar.get("test1"); assertThat(value, is("testValue1")); } @Test public void testGetThrowsNotFoundException() throws Throwable { assertThrows(NameRegistrar.NotFoundException.class, () -> { NameRegistrar.get("NonexistentKey"); }); }
### Question: NameRegistrar implements Loggeable { public static <T> T getIfExists(String key) { @SuppressWarnings("unchecked") T obj = (T) sp.rdp(key); return obj; } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testGetIfExists() throws Throwable { String value = NameRegistrar.getIfExists("test2"); assertThat(value, is("testValue2")); } @Test public void testGetIfExistsWithNotFoundKey() throws Exception { String value = NameRegistrar.getIfExists("NonexistentKey"); assertThat(value, is(nullValue())); }
### Question: NameRegistrar implements Loggeable { public static void unregister(String key) { SpaceUtil.wipe(sp, key); } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testUnregister() throws Exception { assertThrows(NameRegistrar.NotFoundException.class, () -> { NameRegistrar.register("test3", "someTest3Value"); assertThat(NameRegistrar.get("test3"), is("someTest3Value")); NameRegistrar.unregister("test3"); NameRegistrar.get("test3"); }); } @Test public void testUnregisterUnknownKeyDoesNotThrowException() throws Exception { NameRegistrar.unregister("unknownKey"); }
### Question: RemoveNewLinesMapper implements ByteArrayMapper, Configurable { @Override public void setConfiguration(Configuration cfg) throws ConfigurationException { combineSpaces = cfg.getBoolean("combine-spaces", false); newLineAtEnd = cfg.getBoolean("newline-at-end", true); } @Override byte[] apply(byte[] bytes); @Override void setConfiguration(Configuration cfg); }### Answer: @Test void testValuesChangedByConfiguration() throws ConfigurationException { RemoveNewLinesMapper mapper = new RemoveNewLinesMapper(); SimpleConfiguration cfg = new SimpleConfiguration(); cfg.put("combine-spaces", "true"); cfg.put("newline-at-end", "false"); mapper.setConfiguration(cfg); assertTrue(mapper.combineSpaces); assertFalse(mapper.newLineAtEnd); } @Test void testDefaultValues() throws ConfigurationException { RemoveNewLinesMapper mapper = new RemoveNewLinesMapper(); assertFalse(mapper.combineSpaces); assertTrue(mapper.newLineAtEnd); SimpleConfiguration cfg = new SimpleConfiguration(); mapper.setConfiguration(cfg); assertFalse(mapper.combineSpaces); assertTrue(mapper.newLineAtEnd); }
### Question: DefaultTimer { public static Timer getTimer() { if (defaultTimer == null) { synchronized (DefaultTimer.class) { if (defaultTimer == null) defaultTimer = new Timer(true); } } return defaultTimer; } private DefaultTimer(); static Timer getTimer(); }### Answer: @Test public void testGetTimer() throws Throwable { Timer result = DefaultTimer.getTimer(); assertNotNull(result, "result"); }
### Question: DailyLogListener extends RotateLogListener { protected void closeCompressedOutputStream(OutputStream os) throws IOException{ if (os instanceof DeflaterOutputStream) ((DeflaterOutputStream)os).finish(); os.close(); } 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 testCloseCompressedOutputStream() throws Throwable { OutputStream os = new DeflaterOutputStream(new PrintStream(new ByteArrayOutputStream()), new Deflater()); DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.closeCompressedOutputStream(os); assertTrue(true, "Test completed without Exception"); } @Test public void testCloseCompressedOutputStream1() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); OutputStream os = new DataOutputStream(new ByteArrayOutputStream()); dailyLogListener.closeCompressedOutputStream(os); assertEquals(0, ((DataOutputStream) os).size(), "(DataOutputStream) os.size()"); } @Test public void testCloseCompressedOutputStreamThrowsNullPointerException() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); try { dailyLogListener.closeCompressedOutputStream(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.io.OutputStream.close()\" because \"os\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: DailyLogListener extends RotateLogListener { protected void compress(File logFile) { if (getCompressionFormat() != NONE){ Thread t = getCompressorThread(logFile); try{ if (t != null) t.start(); } catch (Exception e){ logDebugEx("error compressing file",e); } } } 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 testCompress() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.compress(new File("testDailyLogListenerParam1")); assertEquals(0, dailyLogListener.getCompressionFormat(), "dailyLogListener.getCompressionFormat()"); }
### Question: DailyLogListener extends RotateLogListener { protected OutputStream getCompressedOutputStream(File f) throws IOException{ OutputStream os = new BufferedOutputStream(new FileOutputStream(f)); if (getCompressionFormat() == ZIP) { ZipOutputStream ret = new ZipOutputStream(os); ret.putNextEntry(new ZipEntry(logName)); return ret; } else { return new GZIPOutputStream(os); } } 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 testGetCompressedOutputStreamThrowsNullPointerException() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); try { dailyLogListener.getCompressedOutputStream(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { } }
### Question: DailyLogListener extends RotateLogListener { protected Thread getCompressorThread(File f){ return new Thread(new Compressor(f),"DailyLogListener-Compressor"); } 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 testGetCompressorThread() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.getCompressorThread(new File("testDailyLogListenerParam1")); assertTrue(true, "Test completed without Exception"); }
### Question: DailyLogListener extends RotateLogListener { protected void logDebugEx(String msg, Throwable e){ ByteArrayOutputStream os = new ByteArrayOutputStream(); PrintStream ps = new PrintStream(os); ps.println(msg); e.printStackTrace(ps); ps.close(); logDebug(os.toString()); } 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 testLogDebugEx() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.logDebugEx("testDailyLogListenerMsg", new NullPointerException("testDailyLogListenerParam1")); assertNotNull(dailyLogListener.p, "dailyLogListener.p"); } @Test public void testLogDebugExThrowsNullPointerException() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); try { dailyLogListener.logDebugEx("testDailyLogListenerMsg", null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.lang.Throwable.printStackTrace(java.io.PrintStream)\" because \"e\" is null", ex.getMessage(), "ex.getMessage()"); } assertNotNull(dailyLogListener.p, "dailyLogListener.p"); } }
### Question: DailyLogListener extends RotateLogListener { public void setCompressedSuffix(String compressedSuffix) { this.compressedSuffix = compressedSuffix; } 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 testSetCompressedSuffix() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setCompressedSuffix("testDailyLogListenerCompressedSuffix"); assertEquals("testDailyLogListenerCompressedSuffix", dailyLogListener.getCompressedSuffix(), "dailyLogListener.getCompressedSuffix()"); }
### Question: DailyLogListener extends RotateLogListener { public void setCompressionBufferSize(int compressionBufferSize) { this.compressionBufferSize = compressionBufferSize >= 0 ? compressionBufferSize : DEF_BUFFER_SIZE; } 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 testSetCompressionBufferSize() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setCompressionBufferSize(-1); assertEquals(131072, dailyLogListener.getCompressionBufferSize(), "dailyLogListener.getCompressionBufferSize()"); }
### Question: DailyLogListener extends RotateLogListener { public void setCompressionFormat(int compressionFormat) { this.compressionFormat = compressionFormat; } 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 testSetCompressionFormat() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setCompressionFormat(100); assertEquals(100, dailyLogListener.getCompressionFormat(), "dailyLogListener.getCompressionFormat()"); }
### Question: DailyLogListener extends RotateLogListener { public void setDateFmt(DateFormat dateFmt) { this.dateFmt = dateFmt; } 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 testSetDateFmt() throws Throwable { DateFormat dateFmt = DateFormat.getInstance(); DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setDateFmt(dateFmt); assertSame(dateFmt, dailyLogListener.getDateFmt(), "dailyLogListener.getDateFmt()"); }
### Question: DailyLogListener extends RotateLogListener { public void setLastDate(String lastDate) { this.lastDate = lastDate; } 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 testSetLastDate() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setLastDate("testDailyLogListenerLastDate"); assertEquals("testDailyLogListenerLastDate", dailyLogListener.getLastDate(), "dailyLogListener.getLastDate()"); }
### 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 = 7243600*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 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: 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 { @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 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 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 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: 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()"); } } }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.