src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
InCriterion extends BasicCriterion { @Override public String toQueryString() { if (value == null || value.isEmpty()) { return "1 > 1"; } return getPropNameWithAlias() + " in " + getParamNameWithColon(); } InCriterion(String propName, Collection<? extends Object> value); InCriterion(String propName, Object[] value); Collection<? extends Object> getValue(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testToQueryString() { assertEquals("rootEntity.name in :rootEntity_name" + instance.hashCode(), instance.toQueryString()); InCriterion other = new InCriterion("name", Arrays.asList(1, 2)); assertEquals("rootEntity.name in :rootEntity_name" + other.hashCode(), other.toQueryString()); } |
InCriterion extends BasicCriterion { @Override public NamedParameters getParameters() { NamedParameters result = NamedParameters.create(); if (!value.isEmpty()) { result = result.add(getParamName(), value); } return result; } InCriterion(String propName, Collection<? extends Object> value); InCriterion(String propName, Object[] value); Collection<? extends Object> getValue(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testGetParameters() { assertEquals(NamedParameters.create() .add("rootEntity_name" + instance.hashCode(), Arrays.asList("a", "b")), instance.getParameters()); } |
InCriterion extends BasicCriterion { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof InCriterion)) { return false; } InCriterion that = (InCriterion) other; return new EqualsBuilder() .append(this.getPropName(), that.getPropName()) .append(value, that.value).isEquals(); } InCriterion(String propName, Collection<? extends Object> value); InCriterion(String propName, Object[] value); Collection<? extends Object> getValue(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testEquals() { assertFalse(instance.equals(null)); assertFalse(instance.equals("abc")); assertTrue(instance.equals(instance)); InCriterion other = new InCriterion("name", Arrays.asList("a", "b")); assertTrue(instance.equals(other)); assertTrue(other.equals(instance)); assertFalse(instance.equals(new InCriterion("name", Arrays.asList("a", "b", "c")))); } |
NotCriterion extends AbstractCriterion { @Override public String toQueryString() { return "not (" + criterion.toQueryString() + ")"; } NotCriterion(QueryCriterion criterion); QueryCriterion getCriteron(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void testToQueryString() { assertEquals("not (a = 1)", instance.toQueryString()); } |
NotCriterion extends AbstractCriterion { @Override public NamedParameters getParameters() { return criterion.getParameters(); } NotCriterion(QueryCriterion criterion); QueryCriterion getCriteron(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void testGetParameters() { assertEquals(other.getParameters(), instance.getParameters()); } |
NotCriterion extends AbstractCriterion { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof NotCriterion)) { return false; } NotCriterion that = (NotCriterion) other; return new EqualsBuilder() .append(this.getCriteron(), that.getCriteron()) .isEquals(); } NotCriterion(QueryCriterion criterion); QueryCriterion getCriteron(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void testEquals() { assertFalse(instance.equals(null)); assertFalse(instance.equals(other)); assertTrue(instance.equals(instance)); NotCriterion another = new NotCriterion(other); assertTrue(instance.equals(another)); assertTrue(another.equals(instance)); } |
StartsWithTextCriterion extends BasicCriterion { public String getValue() { return value; } StartsWithTextCriterion(String propName, String value); String getValue(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testGetValue() { assertEquals("abc", instance.getValue()); } |
StartsWithTextCriterion extends BasicCriterion { @Override public String toQueryString() { return getPropNameWithAlias() + " like " + getParamNameWithColon(); } StartsWithTextCriterion(String propName, String value); String getValue(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testToQueryString() { assertEquals("rootEntity.name like :rootEntity_name" + instance.hashCode(), instance.toQueryString()); } |
StartsWithTextCriterion extends BasicCriterion { @Override public NamedParameters getParameters() { return NamedParameters.create().add(getParamName(), value + "%"); } StartsWithTextCriterion(String propName, String value); String getValue(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testGetParameters() { assertEquals(NamedParameters.create().add("rootEntity_name" + instance.hashCode(), "abc%"), instance.getParameters()); } |
StartsWithTextCriterion extends BasicCriterion { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof StartsWithTextCriterion)) { return false; } StartsWithTextCriterion that = (StartsWithTextCriterion) other; return new EqualsBuilder() .append(this.getPropName(), that.getPropName()) .append(value, that.value) .isEquals(); } StartsWithTextCriterion(String propName, String value); String getValue(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testEquals() { assertFalse(instance.equals(null)); assertFalse(instance.equals("abc")); assertTrue(instance.equals(instance)); StartsWithTextCriterion other = new StartsWithTextCriterion("name", "abc"); assertTrue(instance.equals(other)); assertTrue(other.equals(instance)); } |
OrCriterion extends AbstractCriterion { @Override public String toQueryString() { List<String> subCriteriaStr = new ArrayList<String>(); for (QueryCriterion each : getCriteria()) { subCriteriaStr.add(each.toQueryString()); } return "(" + StringUtils.join(subCriteriaStr, " or ") + ")"; } OrCriterion(QueryCriterion... criteria); List<QueryCriterion> getCriteria(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void testToQueryString() { assertEquals("(a = 1 or b = 2)", instance.toQueryString()); } |
OrCriterion extends AbstractCriterion { @Override public NamedParameters getParameters() { NamedParameters result = NamedParameters.create(); for (QueryCriterion each : getCriteria()) { result.add(each.getParameters()); } return result; } OrCriterion(QueryCriterion... criteria); List<QueryCriterion> getCriteria(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void testGetParameters() { assertEquals(NamedParameters.create().add("name", "abc").add("age", 15), instance.getParameters()); } |
OrCriterion extends AbstractCriterion { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof OrCriterion)) { return false; } OrCriterion that = (OrCriterion) other; return (this.criteria.containsAll(that.criteria)) && that.criteria.containsAll(this.criteria); } OrCriterion(QueryCriterion... criteria); List<QueryCriterion> getCriteria(); @Override String toQueryString(); @Override NamedParameters getParameters(); @Override boolean equals(final Object other); @Override int hashCode(); } | @Test public void testEquals() { assertFalse(instance.equals(null)); assertFalse(instance.equals(criterion1)); assertTrue(instance.equals(instance)); OrCriterion other = new OrCriterion(criterion1, criterion2); assertTrue(instance.equals(other)); assertTrue(other.equals(instance)); } |
NotSpecification extends AbstractSpecification<T> { @Override public boolean isSatisfiedBy(final T t) { return !spec1.isSatisfiedBy(t); } NotSpecification(final Specification<T> spec1); @Override boolean isSatisfiedBy(final T t); } | @Test public void testIsSatisfiedByTrue() { when(specification.isSatisfiedBy(fact)).thenReturn(true); assertFalse(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedByFalse() { when(specification.isSatisfiedBy(fact)).thenReturn(false); assertTrue(instance.isSatisfiedBy(fact)); } |
OrSpecification extends AbstractSpecification<T> { @Override public boolean isSatisfiedBy(final T t) { return spec1.isSatisfiedBy(t) || spec2.isSatisfiedBy(t); } OrSpecification(final Specification<T> spec1, final Specification<T> spec2); @Override boolean isSatisfiedBy(final T t); } | @Test public void testIsSatisfiedByTrueTrue() { when(specification1.isSatisfiedBy(fact)).thenReturn(true); when(specification2.isSatisfiedBy(fact)).thenReturn(true); assertTrue(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedByTrueFalse() { when(specification1.isSatisfiedBy(fact)).thenReturn(true); when(specification2.isSatisfiedBy(fact)).thenReturn(false); assertTrue(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedByFalseTrue() { when(specification1.isSatisfiedBy(fact)).thenReturn(false); when(specification2.isSatisfiedBy(fact)).thenReturn(true); assertTrue(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedByFalseFalse() { when(specification1.isSatisfiedBy(fact)).thenReturn(false); when(specification2.isSatisfiedBy(fact)).thenReturn(false); assertFalse(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedBy() { } |
AndSpecification extends AbstractSpecification<T> { @Override public boolean isSatisfiedBy(final T t) { return spec1.isSatisfiedBy(t) && spec2.isSatisfiedBy(t); } AndSpecification(final Specification<T> spec1, final Specification<T> spec2); @Override boolean isSatisfiedBy(final T t); } | @Test public void testIsSatisfiedByTrueTrue() { when(specification1.isSatisfiedBy(fact)).thenReturn(true); when(specification2.isSatisfiedBy(fact)).thenReturn(true); assertTrue(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedByTrueFalse() { when(specification1.isSatisfiedBy(fact)).thenReturn(true); when(specification2.isSatisfiedBy(fact)).thenReturn(false); assertFalse(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedByFalseTrue() { when(specification1.isSatisfiedBy(fact)).thenReturn(false); when(specification2.isSatisfiedBy(fact)).thenReturn(true); assertFalse(instance.isSatisfiedBy(fact)); }
@Test public void testIsSatisfiedByFalseFalse() { when(specification1.isSatisfiedBy(fact)).thenReturn(false); when(specification2.isSatisfiedBy(fact)).thenReturn(false); assertFalse(instance.isSatisfiedBy(fact)); } |
AbstractSpecification implements Specification<T> { @Override public Specification<T> and(final Specification<T> specification) { return new AndSpecification<T>(this, specification); } @Override Specification<T> and(final Specification<T> specification); @Override Specification<T> or(final Specification<T> specification); @Override Specification<T> not(); } | @Test public void testAnd() { assertTrue(new StartsSpecification("Ha! ") .and(new LengthSpecification(2, 20)) .isSatisfiedBy(data)); assertFalse(new StartsSpecification("Ha! ") .and(new LengthSpecification(5)) .isSatisfiedBy(data)); assertFalse(new StartsSpecification("Ha ") .and(new LengthSpecification(2, 20)) .isSatisfiedBy(data)); } |
AbstractSpecification implements Specification<T> { @Override public Specification<T> or(final Specification<T> specification) { return new OrSpecification<T>(this, specification); } @Override Specification<T> and(final Specification<T> specification); @Override Specification<T> or(final Specification<T> specification); @Override Specification<T> not(); } | @Test public void testOr() { assertTrue(new StartsSpecification("Ha! ") .or(new LengthSpecification(5)) .isSatisfiedBy(data)); assertTrue(new StartsSpecification("Ha ") .or(new LengthSpecification(2, 20)) .isSatisfiedBy(data)); assertFalse(new StartsSpecification("Ha ") .or(new LengthSpecification(5)) .isSatisfiedBy(data)); } |
AbstractSpecification implements Specification<T> { @Override public Specification<T> not() { return new NotSpecification<T>(this); } @Override Specification<T> and(final Specification<T> specification); @Override Specification<T> or(final Specification<T> specification); @Override Specification<T> not(); } | @Test public void testNot() { Specification<String> specification = new LengthSpecification(5); assertTrue(specification.isSatisfiedBy(data)); assertFalse(specification.not().isSatisfiedBy(data)); } |
ConfigurationFactory { public WritableConfiguration fromDatabase(DataSource dataSource) { return instance.fromDatabase(dataSource); } static ConfigurationFactory singleton(); WritableConfiguration fromDatabase(DataSource dataSource); WritableConfiguration fromDatabase(DataSource dataSource, String tableName, String keyColumn, String valueColumn); Configuration fromClasspath(String fileName); WritableConfiguration fromFileSystem(String fileName); WritableConfiguration fromFileSystem(String dirPath, String fileName); WritableConfiguration fromFileSystem(File file); Configuration fromUrl(String url); Configuration fromUrl(URL url); Configuration fromInputStream(InputStream in); } | @Test public void testFromDatabaseDataSource() { final DataSource dataSource = mock(DataSource.class); assertTrue(instance.fromDatabase(dataSource) instanceof ConfigurationDbImpl); }
@Test public void testFromDatabaseDataSourceStringStringString() { final DataSource dataSource = mock(DataSource.class); assertTrue(instance.fromDatabase(dataSource, "table", "key", "value") instanceof ConfigurationDbImpl); } |
ConfigurationFactory { public Configuration fromClasspath(String fileName) { return instance.fromClasspath(fileName); } static ConfigurationFactory singleton(); WritableConfiguration fromDatabase(DataSource dataSource); WritableConfiguration fromDatabase(DataSource dataSource, String tableName, String keyColumn, String valueColumn); Configuration fromClasspath(String fileName); WritableConfiguration fromFileSystem(String fileName); WritableConfiguration fromFileSystem(String dirPath, String fileName); WritableConfiguration fromFileSystem(File file); Configuration fromUrl(String url); Configuration fromUrl(URL url); Configuration fromInputStream(InputStream in); } | @Test public void testFromClasspathString() { assertTrue(instance.fromClasspath("/conf.properties") instanceof ConfigurationInputStreamImpl); } |
ConfigurationFactory { public WritableConfiguration fromFileSystem(String fileName) { return instance.fromFileSystem(fileName); } static ConfigurationFactory singleton(); WritableConfiguration fromDatabase(DataSource dataSource); WritableConfiguration fromDatabase(DataSource dataSource, String tableName, String keyColumn, String valueColumn); Configuration fromClasspath(String fileName); WritableConfiguration fromFileSystem(String fileName); WritableConfiguration fromFileSystem(String dirPath, String fileName); WritableConfiguration fromFileSystem(File file); Configuration fromUrl(String url); Configuration fromUrl(URL url); Configuration fromInputStream(InputStream in); } | @Test public void testFromFileSystemString() { String pathname = getClass().getResource("/conf.properties").getFile(); assertTrue(instance.fromFileSystem(pathname) instanceof ConfigurationFileImpl); }
@Test public void testFromFileSystemStringString() { String pathname = getClass().getResource("/conf.properties").getFile(); File file = new File(pathname); String dir = file.getParent(); String fileName = file.getName(); assertTrue(instance.fromFileSystem(dir, fileName) instanceof ConfigurationFileImpl); }
@Test public void testFromFileSystemFile() { String pathname = getClass().getResource("/conf.properties").getFile(); File file = new File(pathname); assertTrue(file.canRead()); assertTrue(instance.fromFileSystem(file) instanceof ConfigurationFileImpl); } |
ConfigurationFactory { public Configuration fromUrl(String url) { return instance.fromUrl(url); } static ConfigurationFactory singleton(); WritableConfiguration fromDatabase(DataSource dataSource); WritableConfiguration fromDatabase(DataSource dataSource, String tableName, String keyColumn, String valueColumn); Configuration fromClasspath(String fileName); WritableConfiguration fromFileSystem(String fileName); WritableConfiguration fromFileSystem(String dirPath, String fileName); WritableConfiguration fromFileSystem(File file); Configuration fromUrl(String url); Configuration fromUrl(URL url); Configuration fromInputStream(InputStream in); } | @Test public void testFromUrlString() throws IOException { String pathname = getClass().getResource("/conf.properties").getFile(); final File file = new File(pathname); EmbeddedHttpServer httpServer = new EmbeddedHttpServer(1528); httpServer.mapping("/", file); httpServer.start(); String url = "http: assertTrue(instance.fromUrl(url) instanceof ConfigurationInputStreamImpl); httpServer.shutdown(); }
@Test public void testFromUrlURL() throws Exception { String pathname = getClass().getResource("/conf.properties").getFile(); final File file = new File(pathname); EmbeddedHttpServer httpServer = new EmbeddedHttpServer(1528); httpServer.mapping("/", file); httpServer.start(); URL url = new URL("http: assertTrue(instance.fromUrl(url) instanceof ConfigurationInputStreamImpl); httpServer.shutdown(); } |
ConfigurationFileImpl extends AbstractConfiguration implements WritableConfiguration { public static ConfigurationFileImpl fromFile(final File file) { return new ConfigurationFileImpl(file); } ConfigurationFileImpl(final String pathname); ConfigurationFileImpl(final String dirPath, final String fileName); ConfigurationFileImpl(final File file); static ConfigurationFileImpl fromFile(final File file); @Override void load(); @Override void save(); @Override String toString(); } | @Test public void testFromFile() { String pathname = getClass().getResource(fileInClass).getFile(); File file = new File(pathname); instance = ConfigurationFileImpl.fromFile(file); assertTrue(instance.getProperties().size() > 0); } |
ConfigurationFileImpl extends AbstractConfiguration implements WritableConfiguration { @Override public void save() { BufferedWriter out = null; try { out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), PropertiesFileUtils.ISO_8859_1)); store(getProperties(), out, "Config file for " + file); } catch (Exception e) { throw new ConfigurationException(e); } finally { if (out != null) { try { out.close(); } catch (IOException e) { throw new ConfigurationException("Cannot close input stream.", e); } } } } ConfigurationFileImpl(final String pathname); ConfigurationFileImpl(final String dirPath, final String fileName); ConfigurationFileImpl(final File file); static ConfigurationFileImpl fromFile(final File file); @Override void load(); @Override void save(); @Override String toString(); } | @Test public void testSave() { instance.setString("xyz", "yyyy-MM-dd"); ((ConfigurationFileImpl)instance).save(); String fileName = getClass().getResource(fileInClass).getFile(); instance = new ConfigurationFileImpl(new File(fileName)); assertEquals("yyyy-MM-dd", instance.getString("xyz")); } |
ConfigurationDbImpl extends AbstractConfiguration implements WritableConfiguration { @Override public void save() { dbUtils.save(hTable); } ConfigurationDbImpl(DataSource dataSource); ConfigurationDbImpl(DataSource dataSource, String tableName, String keyColumn, String valueColumn); @Override void load(); @Override void save(); } | @Test public void testSave() { instance.setString("xyz", "yyyy-MM-dd"); ((ConfigurationDbImpl)instance).save(); ConfigurationDbImpl instance2 = new ConfigurationDbImpl(dataSource); assertEquals("yyyy-MM-dd", instance2.getString("xyz")); } |
AbstractConfiguration implements Configuration { @Override public String getString(String key, String defaultValue) { Assert.notBlank(key, "Key is null or empty!"); String result = getHashtable().get(key); if (result == null) { result = (String) getHashtable().get(prefix + key); } return result == null ? defaultValue : result; } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetStringStringString() { assertEquals("yyyy-M-d", instance.getString("date.format", "yyyy-MM-dd")); assertEquals("yyyy-MM-dd", instance.getString("format", "yyyy-MM-dd")); }
@Test public void testGetStringString() { assertEquals("yyyy-M-d", instance.getString("date.format")); assertEquals("", instance.getString("format")); assertEquals("张三", instance.getString("name")); } |
AbstractConfiguration implements Configuration { @Override public void setString(String key, String value) { Assert.notBlank(key, "Key is null or empty!"); if (StringUtils.isBlank(value)) { getHashtable().remove(key); return; } getHashtable().put(key, StringPropertyReplacer.replaceProperties(value)); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testSetString() { instance.setString("date.format", "yyyy-MM-dd"); assertEquals("yyyy-MM-dd", instance.getString("date.format")); } |
AbstractConfiguration implements Configuration { @Override public int getInt(String key, int defaultValue) { String result = getString(key, String.valueOf(defaultValue)); return StringUtils.isBlank(result) ? defaultValue : Integer.parseInt(result); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetIntStringInt() { assertEquals(15, instance.getInt("size", 20)); assertEquals(20, instance.getInt("size1", 20)); }
@Test public void testGetIntString() { assertEquals(15, instance.getInt("size")); assertEquals(0, instance.getInt("size1")); } |
AbstractConfiguration implements Configuration { @Override public void setInt(String key, int value) { setString(key, String.valueOf(value)); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testSetInt() { instance.setInt("size", 150); assertEquals(150, instance.getInt("size")); } |
AbstractConfiguration implements Configuration { @Override public long getLong(String key, long defaultValue) { String result = getString(key, String.valueOf(defaultValue)); return StringUtils.isBlank(result) ? defaultValue : Long.parseLong(result); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetLongStringLong() { assertEquals(15L, instance.getLong("size", 20L)); assertEquals(20L, instance.getLong("size1", 20L)); }
@Test public void testGetLongString() { assertEquals(15L, instance.getLong("size")); assertEquals(0L, instance.getLong("size1")); } |
AbstractConfiguration implements Configuration { @Override public void setLong(String key, long value) { setString(key, String.valueOf(value)); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testSetLong() { instance.setLong("size", 150L); assertEquals(150L, instance.getLong("size")); } |
AbstractConfiguration implements Configuration { @Override public double getDouble(String key, double defaultValue) { String result = getString(key, String.valueOf(defaultValue)); return StringUtils.isBlank(result) ? defaultValue : Double.parseDouble(result); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetDoubleStringDouble() { assertEquals(15D, instance.getDouble("size", 20D), 0.001); assertEquals(20D, instance.getDouble("size1", 20D), 0.001); }
@Test public void testGetDoubleString() { assertEquals(15D, instance.getDouble("size"), 0.001); assertEquals(0D, instance.getDouble("size1"), 0.001); } |
AbstractConfiguration implements Configuration { @Override public void setDouble(String key, double value) { setString(key, String.valueOf(value)); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testSetDouble() { instance.setDouble("size", 150D); assertEquals(150D, instance.getDouble("size"), 0.001); } |
AbstractConfiguration implements Configuration { @Override public boolean getBoolean(String key, boolean defaultValue) { String result = getString(key, String.valueOf(defaultValue)); return StringUtils.isBlank(result) ? defaultValue : Boolean.parseBoolean(result); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetBooleanStringBoolean() { assertTrue(instance.getBoolean("closed", false)); assertTrue(instance.getBoolean("closed1", true)); }
@Test public void testGetBooleanString() { assertTrue(instance.getBoolean("closed")); assertFalse(instance.getBoolean("closed1")); } |
AbstractConfiguration implements Configuration { @Override public void setBoolean(String key, boolean value) { setString(key, String.valueOf(value)); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testSetBoolean() { instance.setBoolean("closed", false); assertFalse(instance.getBoolean("size")); } |
AbstractConfiguration implements Configuration { @Override public Date getDate(String key, Date defaultValue) { String result = getString(key); try { return StringUtils.isBlank(result) ? defaultValue : new SimpleDateFormat(dateFormat).parse(result); } catch (ParseException e) { throw new ConfigurationException("日期解析错误！日期格式是：" + dateFormat + ", 日期：" + result, e); } } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetDateStringDate() { Date orig = DateUtils.parseDate("2002-05-11"); Date defaultDate = DateUtils.parseDate("2008-05-11"); assertEquals(orig, instance.getDate("birthday", defaultDate)); assertEquals(defaultDate, instance.getDate("birthday1", defaultDate)); }
@Test public void testGetDateString() { Date orig = DateUtils.parseDate("2002-05-11"); assertEquals(orig, instance.getDate("birthday")); assertEquals(null, instance.getDate("birthday1")); } |
AbstractConfiguration implements Configuration { @Override public void setDate(String key, Date value) { if (value == null) { setString(key, ""); } setString(key, new SimpleDateFormat(dateFormat).format(value)); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testSetDate() { Date newDate = DateUtils.parseDate("2008-05-11"); instance.setDate("birthday", newDate); assertEquals(newDate, instance.getDate("birthday")); } |
AbstractConfiguration implements Configuration { @Override public <T> T getObject(String key, Class<T> objectClass, T defaultValue) { T result = serializer.deserialize(getString(key), objectClass); return result == null ? defaultValue : result; } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetObjectWithDefault() { Item orig = new Item(1, "abc", true); Item defaultItem = new Item(2, "xyz", false); assertEquals(orig, instance.getObject("theItem", Item.class, defaultItem)); assertEquals(defaultItem, instance.getObject("theItem1", Item.class, defaultItem)); }
@Test public void testGetObjectWithoutDefault() { Item orig = new Item(1, "abc", true); assertEquals(orig, instance.getObject("theItem", Item.class)); assertNull(instance.getObject("theItem1", Item.class)); } |
AbstractConfiguration implements Configuration { @Override public void setObject(String key, Object value) { setString(key, serializer.serialize(value)); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testSetObject() { Date newDate = DateUtils.parseDate("2008-05-11"); instance.setObject("theDay", newDate); assertEquals(newDate, instance.getObject("theDay", Date.class)); } |
AbstractConfiguration implements Configuration { @Override public Properties getProperties() { return pfu.unRectifyProperties(getHashtable()); } String getDateFormat(); void setDateFormat(String dateFormat); void usePrefix(final String prefix); @Override String getString(String key, String defaultValue); @Override String getString(String key); @Override void setString(String key, String value); @Override int getInt(String key, int defaultValue); @Override int getInt(String key); @Override void setInt(String key, int value); @Override long getLong(String key, long defaultValue); @Override long getLong(String key); @Override void setLong(String key, long value); @Override double getDouble(String key, double defaultValue); @Override double getDouble(String key); @Override void setDouble(String key, double value); @Override boolean getBoolean(String key, boolean defaultValue); @Override boolean getBoolean(String key); @Override void setBoolean(String key, boolean value); @Override Date getDate(String key, Date defaultValue); @Override Date getDate(String key); @Override void setDate(String key, Date value); @Override T getObject(String key, Class<T> objectClass, T defaultValue); @Override T getObject(String key, Class<T> objectClass); @Override void setObject(String key, Object value); @Override Properties getProperties(); } | @Test public void testGetProperties() { Properties properties = instance.getProperties(); assertEquals("15", properties.get("size")); } |
EntityRepositoryJpa implements EntityRepository { @Override public NamedQuery createNamedQuery(String queryName) { return new NamedQuery(this, queryName); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCreateNamedQuery() { String queryName = "Dictionary.findByCategory"; NamedQuery query = repository.createNamedQuery(queryName); assertEquals(queryName, query.getQueryName()); } |
StatefulRuleTemplate { public void execute(StatefulRuleCallback callback) throws Exception { StatefulRuleSession session = getStatefulRuleSession(); try { callback.doInRuleSession(session); } finally { releaseStatefulRuleSession(session); } } StatefulRuleTemplate(RuleServiceProvider ruleServiceProvider); StatefulRuleTemplate(RuleServiceProvider ruleServiceProvider, Map serviceProviderProperties); final StatefulRuleTemplate sessionProperties(Map sessionProperties); final StatefulRuleTemplate ruleSource(Object ruleSource, Map executionSetProperties); final StatefulRuleTemplate ruleSource(Object ruleSource); void execute(StatefulRuleCallback callback); StatefulRuleSession getStatefulRuleSession(); } | @Test public void testExecute() throws Exception { instance.execute(new StatefulRuleCallback() { @Override public void doInRuleSession(StatefulRuleSession session) throws Exception { session.addObject(chencao); session.addObject(xishi); session.addObject(yyang); session.executeRules(); } }); assertEquals(60, chencao.getRetireAge()); assertEquals(55, xishi.getRetireAge()); assertEquals(60, yyang.getRetireAge()); } |
StatelessRuleServiceJsr94 implements StatelessRuleService { @Override public List executeRules(List facts) { try { return session.executeRules(facts); } catch (InvalidRuleSessionException e) { throw new RuleRuntimeException("Invalid Rule Session.", e); } catch (RemoteException e) { throw new IllegalStateException(e); } } private StatelessRuleServiceJsr94(RuleServiceProvider ruleServiceProvider, Map serviceProviderProperties,
Object ruleSource, Map executionSetProperties, Map sessionProperties); @Override List executeRules(List facts); void release(); static Builder builder(); } | @Test public void testExecuteRules() { instance = StatelessRuleServiceJsr94.builder() .ruleServiceProvider(new RuleServiceProviderImpl()) .serviceProviderProperties(null) .executionSetProperties(null) .ruleSource(getClass().getResourceAsStream(ruleDrl)) .sessionProperties(null) .bulid(); List results = instance.executeRules(Arrays.asList(chencao, xishi, yyang)); assertEquals(60, chencao.getRetireAge()); assertEquals(55, xishi.getRetireAge()); assertEquals(60, yyang.getRetireAge()); instance.release(); } |
SimpleEventBus implements EventBus { List<EventListener> getListeners() { return listeners; } SimpleEventBus(EventStore eventStore); SimpleEventBus(EventStore eventStore, List<EventListener> listeners); @Override void register(EventListener... listeners); @Override void unregister(EventListener... listeners); @Override void post(Event event); } | @Test public void createWithListeners() { List<EventListener> listeners = new ArrayList<EventListener>(); listeners.add(employeeRetiredEventListener); listeners.add(postCreatedEventListener); instance = new SimpleEventBus(eventStore, listeners); assertThat(instance.getListeners()).isEqualTo(listeners); } |
User extends Actor implements Principal { public String getPassword() { return password; } User(); User(String name, String password); String getPassword(); void setPassword(String password); String getPasswordHint(); void setPasswordHint(String passwordHint); boolean isLocked(); void setLocked(boolean locked); @Override String[] businessKeys(); void lock(); void unlock(); void changePassword(String origPassword, String newPassword); boolean matchPassword(String password); boolean unmatchPassword(String password); static boolean existsUsername(String username); static User get(String id); static User getByName(String name); static List<User> list(); static boolean authenticate(String username, String password); static User create(String username); static User create(String username, String password); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); } | @Test public void constructor() { user = new MyUser("zhang", "123"); assertThat(user.getName(), is("zhang")); assertThat(user.getPassword(), is("123")); } |
EhCacheBasedCache implements Cache { public Object get(String key) { Element el = (Element) cache.get(key); if (el != null) { return el.getObjectValue(); } return null; } EhCacheBasedCache(String name); EhCacheBasedCache(EhCacheConfiguration configuration); EhCacheBasedCache(String name, int maxElementsInMemory, boolean overflowToDisk, boolean eternal, long timeToLiveSeconds, long timeToIdleSeconds); Object get(String key); Map<String, Object> get(String... keys); boolean containsKey(String key); void put(String key, Object obj); void put(String key, Object obj, Date expiredDate); void put(String key, Object obj, long timeToLiveSeconds); boolean remove(String key); } | @Test public void testGet() { Cache cache = new EhCacheBasedCache("sampleCache"); cache.put("KEY1", "Koala Project"); assertTrue("Koala Project".equals(cache.get("KEY1"))); assertNull(cache.get("KEY2")); cache.remove("KEY1"); } |
MemcachedBasedCache implements Cache { public Object get(String key) { init(); Object obj = mcc.get(key); debug("命中缓存：{}，key：{}", new Object[] { (obj != null), key }); return obj; } Object get(String key); @Override Map<String, Object> get(String... keys); boolean containsKey(String key); void put(String key, Object value); void put(String key, Object value, Date expiry); void put(String key, Object value, long living); boolean remove(String key); String[] getServers(); void setServers(String... servers); int getInitConn(); void setInitConn(int initConn); int getMinConn(); void setMinConn(int minConn); int getMaxConn(); void setMaxConn(int maxConn); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); String getPoolName(); void setPoolName(String poolName); void init(); } | @Test public void get() { Object obj = cache.get("hehe"); assertNull(obj); } |
MemcachedBasedCache implements Cache { public void put(String key, Object value) { init(); mcc.set(key, value); debug("缓存数据，key：{}", key); } Object get(String key); @Override Map<String, Object> get(String... keys); boolean containsKey(String key); void put(String key, Object value); void put(String key, Object value, Date expiry); void put(String key, Object value, long living); boolean remove(String key); String[] getServers(); void setServers(String... servers); int getInitConn(); void setInitConn(int initConn); int getMinConn(); void setMinConn(int minConn); int getMaxConn(); void setMaxConn(int maxConn); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); String getPoolName(); void setPoolName(String poolName); void init(); } | @Test public void put() throws InterruptedException { try { Thread.sleep(1000); Date now = new Date(); cache.put("time", now); Date obj = (Date) cache.get("time"); assertNotNull(obj); assertEquals(now, obj); } catch (RuntimeException ex) { System.err.println("出错了..." + ex); throw ex; } } |
MemcachedBasedCache implements Cache { public boolean remove(String key) { init(); boolean result = mcc.delete(key); debug("删除缓存，key：{}", key); return result; } Object get(String key); @Override Map<String, Object> get(String... keys); boolean containsKey(String key); void put(String key, Object value); void put(String key, Object value, Date expiry); void put(String key, Object value, long living); boolean remove(String key); String[] getServers(); void setServers(String... servers); int getInitConn(); void setInitConn(int initConn); int getMinConn(); void setMinConn(int minConn); int getMaxConn(); void setMaxConn(int maxConn); int getConnectTimeout(); void setConnectTimeout(int connectTimeout); String getPoolName(); void setPoolName(String poolName); void init(); } | @Test public void remove() { assertFalse(cache.remove("no-exist")); Date now = new Date(); cache.put("time", now); boolean delete = cache.remove("time"); assertTrue(delete); } |
Assert { public static void isTrue(boolean expression, String message) { if (!expression) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testIsTrueWithMessageFailure() { Assert.isTrue(false, "Failure!"); }
@Test() public void testIsTrueWithMessageSuccess() { Assert.isTrue(3 > 2, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsTrueFailure() { Assert.isTrue(false); }
@Test() public void testIsTrueSuccess() { Assert.isTrue(3 > 2); } |
Assert { public static void isFalse(boolean expression, String message) { if (expression) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testIsFalseWithMessageFailure() { Assert.isFalse(true, "Failure!"); }
@Test() public void testIsFalseWithMessageSuccess() { Assert.isFalse(3 < 2, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsFalseFailure() { Assert.isFalse(true); }
@Test() public void testIsFalseSuccess() { Assert.isFalse(3 < 2); } |
Assert { public static void isNull(Object object, String message) { if (object != null) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testIsNullWithMessageFailure() { Assert.isNull("Hi", "Failure!"); }
@Test() public void testIsNullWithMessageSuccess() { Assert.isNull(null, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsNullFailure() { Assert.isNull("Hi"); }
@Test() public void testIsNullSuccess() { Assert.isNull(null); } |
Assert { public static void notNull(Object object, String message) { if (object == null) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testNotNullWithMessageFailure() { Assert.notNull(null, "Failure!"); }
@Test() public void testNotNullWithMessageSuccess() { Assert.notNull("Hi", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotNullFailure() { Assert.notNull(null); }
@Test() public void testNotNullSuccess() { Assert.notNull("Hi"); } |
Assert { public static void isEmpty(CharSequence text, String message) { if (StringUtils.isNotEmpty(text)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testIsEmptyStringWithMessageFailure() { Assert.isEmpty("Hi", "Failure!"); }
@Test() public void testIsEmptyStringWithMessageSuccess() { Assert.isEmpty((String) null, "Failure!"); Assert.isEmpty("", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsEmptyStringFailure() { Assert.isEmpty("Hi"); }
@Test() public void testIsEmptyStringSuccess() { Assert.isEmpty((String) null); }
@Test(expected = IllegalArgumentException.class) public void testIsEmptyArrayWithMessageFailure() { Assert.isEmpty(new String[] {"abc"}, "Failure!"); }
@Test() public void testIsEmptyArrayWithMessageSuccess() { String[] array = null; Assert.isEmpty(array, "Failure!"); Assert.isEmpty(new String[] {}, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsEmptyArrayFailure() { Assert.isEmpty(new String[] {"abc"}); }
@Test() public void testIsEmptyArraySuccess() { Assert.isEmpty((Object[]) null); }
@Test(expected = IllegalArgumentException.class) public void testIsEmptyCollectionWithMessageFailure() { Assert.isEmpty(Collections.singleton("abc"), "Failure!"); }
@Test() public void testIsEmptyCollectionWithMessageSuccess() { List list = null; Assert.isEmpty(list, "Failure!"); Assert.isEmpty(Collections.EMPTY_LIST, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsEmptyCollectionFailure() { Assert.isEmpty(Collections.singleton("abc")); }
@Test() public void testIsEmptyCollectionSuccess() { Assert.isEmpty((List) null); }
@Test(expected = IllegalArgumentException.class) public void testIsEmptyMapWithMessageFailure() { Assert.isEmpty(Collections.singletonMap("abc", "xyz"), "Failure!"); }
@Test() public void testIsEmptyMapWithMessageSuccess() { Assert.isEmpty((Map) null, "Failure!"); Assert.isEmpty(Collections.EMPTY_MAP, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsEmptyMapFailure() { Assert.isEmpty(Collections.singletonMap("abc", "xyz")); }
@Test() public void testIsEmptyMapSuccess() { Assert.isEmpty((Map) null); Assert.isEmpty(Collections.EMPTY_MAP); } |
Assert { public static void notEmpty(CharSequence text, String message) { if (StringUtils.isEmpty(text)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testNotEmptyStringWithMessageFailure() { Assert.notEmpty((String) null, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyStringWithMessageFailure1() { Assert.notEmpty("", "Failure!"); }
@Test() public void testNotEmptyStringWithMessageSuccess() { Assert.notEmpty("Hi", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyStringFailure() { Assert.notEmpty((String) null); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyStringFailure1() { Assert.notEmpty(""); }
@Test() public void testNotEmptyStringSuccess() { Assert.notEmpty("Hi"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyArrayWithMessageFailure() { String[] array = null; Assert.notEmpty(array, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyArrayWithMessageFailure1() { Assert.notEmpty(new String[] {}, "Failure!"); }
@Test() public void testNotEmptyArrayWithMessageSuccess() { Assert.notEmpty(new String[] {"abc"}, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyArrayFailure() { String[] array = null; Assert.notEmpty(array); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyArrayFailure1() { Assert.notEmpty(new String[] {}); }
@Test() public void testNotEmptyArraySuccess() { Assert.notEmpty(new String[] {"abc"}); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyCollectionWithMessageFailure() { List list = null; Assert.notEmpty(list, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyCollectionWithMessageFailure1() { Assert.notEmpty(Collections.EMPTY_LIST, "Failure!"); }
@Test() public void testNotEmptyCollectionWithMessageSuccess() { Assert.notEmpty(Collections.singleton("abc"), "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyCollectionFailure() { List list = null; Assert.notEmpty(list); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyCollectionFailure1() { Assert.notEmpty(Collections.EMPTY_LIST); }
@Test() public void testNotEmptyCollectionSuccess() { Assert.notEmpty(Collections.singleton("abc")); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyMapWithMessageFailure() { Assert.notEmpty((Map) null, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyMapWithMessageFailure1() { Assert.notEmpty(Collections.EMPTY_MAP, "Failure!"); }
@Test() public void testNotEmptyMapWithMessageSuccess() { Assert.notEmpty(Collections.singletonMap("abc", "xyz"), "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyMapFailure() { Assert.notEmpty((Map) null); }
@Test(expected = IllegalArgumentException.class) public void testNotEmptyMapFailure1() { Assert.notEmpty(Collections.EMPTY_MAP); }
@Test() public void testNotEmptyMapSuccess() { Assert.notEmpty(Collections.singletonMap("abc", "xyz")); } |
EntityRepositoryJpa implements EntityRepository { @Override public SqlQuery createSqlQuery(String sql) { return new SqlQuery(this, sql); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCreateSqlQuery() { String sql = "select * from dictionaries"; SqlQuery query = repository.createSqlQuery(sql); assertEquals(sql, query.getSql()); } |
Assert { public static void isBlank(CharSequence text, String message) { if (StringUtils.isNotBlank(text)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testIsBlankWithMessageFailure() { Assert.isBlank("Hi", "Failure!"); }
@Test() public void testIsBlankWithMessageSuccess() { Assert.isBlank((String) null, "Failure!"); Assert.isBlank("", "Failure!"); Assert.isBlank(" ", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testIsBlankFailure() { Assert.isBlank("Hi"); }
@Test() public void testIsBlankSuccess() { Assert.isBlank((String) null); Assert.isBlank(""); Assert.isBlank(" "); } |
Assert { public static void notBlank(CharSequence text, String message) { if (StringUtils.isBlank(text)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testNotBlankWithMessageFailure() { Assert.notBlank((String) null, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotBlankWithMessageFailure1() { Assert.notBlank("", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotBlankWithMessageFailure2() { Assert.notBlank(" ", "Failure!"); }
@Test() public void testNotBlankWithMessageSuccess() { Assert.notBlank("Hi", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotBlankFailure() { Assert.notBlank((String) null); }
@Test(expected = IllegalArgumentException.class) public void testNotBlankFailure1() { Assert.notBlank(""); }
@Test(expected = IllegalArgumentException.class) public void testNotBlankFailure2() { Assert.notBlank(" "); }
@Test() public void testNotBlankSuccess() { Assert.notBlank("Hi"); } |
Assert { public static void containsText(String textToSearch, String substring, String message) { if (!StringUtils.isEmpty(textToSearch) && !StringUtils.isEmpty(substring) && textToSearch.indexOf(substring) == -1) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testContainsTextWithMessageFailure() { Assert.containsText("Hi", "Haha", "Failure!"); }
@Test() public void testContainsTextWithMessageSuccess() { Assert.containsText("abc", "a", "Failure!"); Assert.containsText("abc", "b", "Failure!"); Assert.containsText("abc", "c", "Failure!"); Assert.containsText("abc", "ab", "Failure!"); Assert.containsText("abc", "abc", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testContainsTextFailure() { Assert.containsText("Hi", "Haha"); }
@Test() public void testContainsTextSuccess() { Assert.containsText("abc", "a"); Assert.containsText("abc", "b"); Assert.containsText("abc", "c"); Assert.containsText("abc", "ab"); Assert.containsText("abc", "abc"); } |
Assert { public static void notContainsText(String textToSearch, String substring, String message) { if (!StringUtils.isEmpty(textToSearch) && !StringUtils.isEmpty(substring) && textToSearch.indexOf(substring) != -1) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testNotContainsTextWithMessageFailure1() { Assert.notContainsText("abc", "a", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextWithMessageFailure2() { Assert.notContainsText("abc", "b", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextWithMessageFailure3() { Assert.notContainsText("abc", "c", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextWithMessageFailure4() { Assert.notContainsText("abc", "ab", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextWithMessageFailure5() { Assert.notContainsText("abc", "abc", "Failure!"); }
@Test() public void testNotContainsTextWithMessageSuccess() { Assert.notContainsText("abc", "ac", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextFailure1() { Assert.notContainsText("abc", "a"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextFailure2() { Assert.notContainsText("abc", "b"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextFailure3() { Assert.notContainsText("abc", "c"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextFailure4() { Assert.notContainsText("abc", "ab"); }
@Test(expected = IllegalArgumentException.class) public void testNotContainsTextFailure5() { Assert.notContainsText("abc", "abc"); }
@Test() public void testNotContainsTextSuccess() { Assert.notContainsText("abc", "ac"); } |
Assert { public static void startsWithText(String textToSearch, String substring, String message) { if (!StringUtils.isEmpty(textToSearch) && !StringUtils.isEmpty(substring) && !textToSearch.startsWith(substring)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testStartsWithTextWithMessageFailure() { Assert.startsWithText("abc", "ac", "Failure!"); }
@Test() public void testStartsWithTextWithMessageSuccess() { Assert.startsWithText("abc", "a", "Failure!"); Assert.startsWithText("abc", "ab", "Failure!"); Assert.startsWithText("abc", "abc", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testStartsWithTextFailure() { Assert.startsWithText("abc", "ac"); }
@Test() public void testStartsWithTextSuccess() { Assert.startsWithText("abc", "a"); Assert.startsWithText("abc", "ab"); Assert.startsWithText("abc", "abc"); } |
Assert { public static void notStartsWithText(String textToSearch, String substring, String message) { if (!StringUtils.isEmpty(textToSearch) && !StringUtils.isEmpty(substring) && textToSearch.startsWith(substring)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testNotStartsWithTextWithMessageFailure1() { Assert.notStartsWithText("abc", "a", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotStartsWithTextWithMessageFailure2() { Assert.notStartsWithText("abc", "ab", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotStartsWithTextWithMessageFailure3() { Assert.notStartsWithText("abc", "abc", "Failure!"); }
@Test() public void testNotStartsWithTextWithMessageSuccess() { Assert.notStartsWithText("abc", "ac", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotStartsWithTextFailure1() { Assert.notStartsWithText("abc", "a"); }
@Test(expected = IllegalArgumentException.class) public void testNotStartsWithTextFailure2() { Assert.notStartsWithText("abc", "ab"); }
@Test(expected = IllegalArgumentException.class) public void testNotStartsWithTextFailure3() { Assert.notStartsWithText("abc", "abc"); }
@Test() public void testNotStartsWithTextSuccess() { Assert.notStartsWithText("abc", "ac"); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> boolean exists(final Class<T> clazz, final Serializable id) { T entity = getEntityManager().find(clazz, id); return entity != null; } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testExists() { assertTrue(repository.exists(Dictionary.class, male.getId())); assertFalse(repository.exists(Dictionary.class, 1000L)); } |
Assert { public static void endsWithText(String textToSearch, String substring, String message) { if (!StringUtils.isEmpty(textToSearch) && !StringUtils.isEmpty(substring) && !textToSearch.endsWith(substring)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testEndsWithTextWithMessageFailure() { Assert.endsWithText("abc", "ac", "Failure!"); }
@Test() public void testEndsWithTextWithMessageSuccess() { Assert.endsWithText("abc", "c", "Failure!"); Assert.endsWithText("abc", "bc", "Failure!"); Assert.endsWithText("abc", "abc", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testEndsWithTextFailure() { Assert.endsWithText("abc", "ac"); }
@Test() public void testEndsWithTextSuccess() { Assert.endsWithText("abc", "c"); Assert.endsWithText("abc", "bc"); Assert.endsWithText("abc", "abc"); } |
Assert { public static void notEndsWithText(String textToSearch, String substring, String message) { if (!StringUtils.isEmpty(textToSearch) && !StringUtils.isEmpty(substring) && textToSearch.endsWith(substring)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testNotEndsWithTextWithMessageFailure1() { Assert.notEndsWithText("abc", "c", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEndsWithTextWithMessageFailure2() { Assert.notEndsWithText("abc", "bc", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEndsWithTextWithMessageFailure3() { Assert.notEndsWithText("abc", "abc", "Failure!"); }
@Test() public void testNotEndsWithTextWithMessageSuccess() { Assert.notEndsWithText("abc", "ac", "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNotEndsWithTextFailure1() { Assert.notEndsWithText("abc", "c"); }
@Test(expected = IllegalArgumentException.class) public void testNotEndsWithTextFailure2() { Assert.notEndsWithText("abc", "bc"); }
@Test(expected = IllegalArgumentException.class) public void testNotEndsWithTextFailure3() { Assert.notEndsWithText("abc", "abc"); }
@Test() public void testNotEndsWithTextSuccess() { Assert.notEndsWithText("abc", "ac"); } |
Assert { public static void noNullElements(Object[] array, String message) { if (array == null) { return; } for (Object each : array) { notNull(each, message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testNoNullElementsArrayWithMessageFailure() { Object[] results = {"abc", null}; Assert.noNullElements(results, "Failure!"); }
@Test public void testNoNullElementsArrayWithMessageSuccess() { Object[] results = {"abc", 123}; Assert.noNullElements(results, "Failure!"); }
@Test public void testNoNullElementsArrayWithMessageSuccess1() { Object[] results = null; Assert.noNullElements(results, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNoNullElementsArrayFailure() { Object[] results = {"abc", null}; Assert.noNullElements(results); }
@Test public void testNoNullElementsArraySuccess() { Object[] results = {"abc", 123}; Assert.noNullElements(results); }
@Test(expected = IllegalArgumentException.class) public void testNoNullElementsCollectionWithMessageFailure() { List<Object> results = Arrays.asList(new Object[] {"abc", null}); Assert.noNullElements(results, "Failure!"); }
@Test public void testNoNullElementsCollectionWithMessageSuccess() { List<Object> results = Arrays.asList(new Object[] {"abc", 123}); Assert.noNullElements(results, "Failure!"); }
@Test public void testNoNullElementsCollectionWithMessageSuccess1() { List results = null; Assert.noNullElements(results, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNoNullElementsCollectionFailure() { List<Object> results = Arrays.asList(new Object[] {"abc", null}); Assert.noNullElements(results); }
@Test public void testNoNullElementsCollectionSuccess() { List<Object> results = Arrays.asList(new Object[] {"abc", 123}); Assert.noNullElements(results); }
@Test(expected = IllegalArgumentException.class) public void testNoNullElementsMapWithMessageFailure() { Map results = new HashMap(); results.put("a", "abc"); results.put("b", null); Assert.noNullElements(results, "Failure!"); }
@Test public void testNoNullElementsMapWithMessageSuccess() { Map results = new HashMap(); results.put("a", "abc"); results.put("b", 123); Assert.noNullElements(results, "Failure!"); }
@Test public void testNoNullElementsMapWithMessageSuccess1() { Map results = null; Assert.noNullElements(results, "Failure!"); }
@Test(expected = IllegalArgumentException.class) public void testNoNullElementsMapFailure() { Map results = new HashMap(); results.put("a", "abc"); results.put("b", null); Assert.noNullElements(results); }
@Test public void testNoNullElementsMapSuccess() { Map results = new HashMap(); results.put("a", "abc"); results.put("b", 123); Assert.noNullElements(results); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity, E extends T> List<T> findByExample( final E example, final ExampleSettings<T> settings) { throw new RuntimeException("not implemented yet!"); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Ignore @Test public void testFindByExample() { Dictionary example = new Dictionary(null, "本", null); List<Dictionary> dictionaries = repository.findByExample(example, ExampleSettings.create(Dictionary.class).excludeZeroes()); assertFalse(dictionaries.contains(male)); assertFalse(dictionaries.contains(undergraduate)); dictionaries = repository.findByExample(example, ExampleSettings.create(Dictionary.class).excludeZeroes().enableLike()); assertTrue(dictionaries.contains(undergraduate)); assertFalse(dictionaries.contains(male)); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue) { return find(new CriteriaQuery(this, clazz).eq(propertyName, propertyValue)); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFindByProperty() { List<Dictionary> results = repository.findByProperty(Dictionary.class, "category", education); assertTrue(results.contains(undergraduate)); assertTrue(results.contains(graduate)); assertFalse(results.contains(male)); } |
Assert { public static void isInstanceOf(Class type, Object obj, String message) { notNull(type, "Type to check against must not be null"); if (!type.isInstance(obj)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testIsInstanceOfWithMessageFailure() { Assert.isInstanceOf(String.class, 123, "Failure"); }
@Test public void testIsInstanceOfWithMessageSuccess() { Assert.isInstanceOf(Number.class, 12.5, "Failure"); }
@Test(expected = IllegalArgumentException.class) public void testIsInstanceOfFailure() { Assert.isInstanceOf(String.class, 123); }
@Test public void testIsInstanceOfSuccess() { Assert.isInstanceOf(Number.class, 12.5); } |
Assert { @SuppressWarnings("unchecked") public static void isAssignableFrom(Class superType, Class subType, String message) { notNull(superType, "Type to check against must not be null"); if (subType == null || !superType.isAssignableFrom(subType)) { throw new IllegalArgumentException(message); } } private Assert(); static void isTrue(boolean expression, String message); static void isTrue(boolean expression); static void isFalse(boolean expression, String message); static void isFalse(boolean expression); static void isNull(Object object, String message); static void isNull(Object object); static void notNull(Object object, String message); static void notNull(Object object); static void isEmpty(CharSequence text, String message); static void isEmpty(CharSequence text); static void notEmpty(CharSequence text, String message); static void notEmpty(CharSequence text); static void isEmpty(Object[] array, String message); static void isEmpty(Object[] array); static void notEmpty(Object[] array, String message); static void notEmpty(Object[] array); static void isEmpty(Collection collection, String message); static void isEmpty(Collection collection); static void notEmpty(Collection collection, String message); static void notEmpty(Collection collection); static void isEmpty(Map map, String message); static void isEmpty(Map map); static void notEmpty(Map map, String message); static void notEmpty(Map map); static void isBlank(CharSequence text, String message); static void isBlank(CharSequence text); static void notBlank(CharSequence text, String message); static void notBlank(CharSequence text); static void containsText(String textToSearch, String substring,
String message); static void containsText(String textToSearch, String substring); static void notContainsText(String textToSearch, String substring,
String message); static void notContainsText(String textToSearch, String substring); static void startsWithText(String textToSearch, String substring,
String message); static void startsWithText(String textToSearch, String substring); static void notStartsWithText(String textToSearch, String substring,
String message); static void notStartsWithText(String textToSearch, String substring); static void endsWithText(String textToSearch, String substring,
String message); static void endsWithText(String textToSearch, String substring); static void notEndsWithText(String textToSearch, String substring,
String message); static void notEndsWithText(String textToSearch, String substring); static void noNullElements(Object[] array, String message); static void noNullElements(Object[] array); static void noNullElements(Collection collection, String message); static void noNullElements(Collection collection); static void noNullElements(Map map, String message); static void noNullElements(Map map); static void isInstanceOf(Class type, Object obj, String message); static void isInstanceOf(Class type, Object obj); @SuppressWarnings("unchecked") static void isAssignableFrom(Class superType, Class subType,
String message); static void isAssignableFrom(Class superType, Class subType); } | @Test(expected = IllegalArgumentException.class) public void testIsAssignableFromWithMessageFailure() { Assert.isAssignableFrom(String.class, Integer.class, "Failure"); }
@Test public void testIsAssignableFromWithMessageSuccess() { Assert.isAssignableFrom(Number.class, Double.class, "Failure"); }
@Test(expected = IllegalArgumentException.class) public void testIsAssignableFromFailure() { Assert.isAssignableFrom(String.class, Integer.class); }
@Test public void testIsAssignableFromSuccess() { Assert.isAssignableFrom(Number.class, Double.class); } |
IntRange implements Serializable { public boolean contains(int number) { return number >= min && number <= max; } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); } | @Test public void testContains() { assertTrue(range.contains(7)); assertTrue(range.contains(1)); assertTrue(range.contains(10)); assertFalse(range.contains(0)); assertFalse(range.contains(-1)); assertFalse(range.contains(11)); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findByProperties(Class<T> clazz, NamedParameters properties) { CriteriaQuery criteriaQuery = new CriteriaQuery(this, clazz); for (Map.Entry<String, Object> each : properties.getParams().entrySet()) { criteriaQuery = criteriaQuery.eq(each.getKey(), each.getValue()); } return find(criteriaQuery); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFindByProperties() { NamedParameters params = NamedParameters.create() .add("category", education) .add("code", "02"); List<Dictionary> results = repository.findByProperties(Dictionary.class, params); assertTrue(results.contains(graduate)); assertFalse(results.contains(undergraduate)); assertFalse(results.contains(male)); } |
IntRange implements Serializable { @Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof IntRange)) { return false; } IntRange that = (IntRange) other; return new EqualsBuilder().append(this.getMin(), that.getMin()) .append(this.getMax(), that.getMax()) .isEquals(); } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); } | @Test public void testEqualsObject() { IntRange range1 = new IntRange(1, 10); assertEquals(range1, range); range1 = new IntRange(1, 11); assertFalse(range1.equals(range)); range1 = new IntRange(2, 10); assertFalse(range1.equals(range)); } |
IntRange implements Serializable { @Override public String toString() { return "[" + min + " - " + max + "]"; } IntRange(int min, int max); int getMin(); int getMax(); boolean contains(int number); @Override int hashCode(); @Override boolean equals(Object other); @Override String toString(); } | @Test public void testToString() { assertEquals("[1 - 10]", range.toString()); } |
GsonSerializer implements ObjectSerializer { @Override public String serialize(Object anObject) { return gson.toJson(anObject); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); } | @Test public void notSerializeNulls() throws Exception { String result = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
@Test public void serializeNulls() { instance = builder.serializeNulls().build(); String result = "{\"prop1\":\"abc\",\"prop2\":null,\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
@Test public void prettyPrinting() { instance = builder.prettyPrinting().build(); String lineSeparator = System.getProperty("line.separator"); String result = String.format( "{\n \"prop1\": \"abc\",\n \"lastModified\": \"2002-12-11\",\n \"id\": \"anId\",\n \"occurredOn\": \"2002-04-11\",\n \"version\": 1\n}", lineSeparator, lineSeparator, lineSeparator, lineSeparator, lineSeparator); assertThat(instance.serialize(event), is(result)); }
@Test public void excludeFieldsNamed() throws Exception { String result = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"version\":1}"; instance = builder.excludeFieldsNamed("occurredOn").build(); assertThat(instance.serialize(event), is(result)); }
@Test public void excludeFieldsWithModifiers() { instance = builder.excludeFieldsWithModifiers(Modifier.PROTECTED, Modifier.TRANSIENT).build(); String result = "{\"prop1\":\"abc\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
@Test public void test() { DictionaryCategory category = new DictionaryCategory(); category.setName("a category"); category.setSortOrder(1); category.setId(3L); Dictionary dictionary1 = new Dictionary("01", "男", category); Dictionary dictionary2 = new Dictionary("01", "男", category); Set<Dictionary> dictionaries = new HashSet<Dictionary>(); dictionaries.add(dictionary1); dictionaries.add(dictionary2); category.setDictionaries(dictionaries); System.out.println(instance.serialize(category)); }
@Test public void registerTypeAdapter() { builder = builder.registerTypeAdapter(Date.class, new JsonSerializer<Date>() { @Override public JsonElement serialize(Date source, Type typeOfSource, JsonSerializationContext context) { return new JsonPrimitive(source.getTime()); } }); instance = builder.build(); String result = "{\"prop1\":\"abc\",\"lastModified\":1039536000000,\"id\":\"anId\",\"occurredOn\":1018454400000,\"version\":1}"; assertThat(instance.serialize(event), is(result)); }
@Test public void addSerializationExclusionStrategy() { builder = builder.addSerializationExclusionStrategy(new FieldNameExclusionStrategy("occurredOn")); String result = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"version\":1}"; instance = builder.build(); assertThat(instance.serialize(event), is(result)); } |
GsonSerializer implements ObjectSerializer { @Override public <T> T deserialize(String serializedString, Class<T> objectClass) { return gson.fromJson(serializedString, objectClass); } GsonSerializer(); GsonSerializer(Gson gson); @Override String serialize(Object anObject); @Override T deserialize(String serializedString, Class<T> objectClass); } | @Test public void deserialize() throws Exception { String eventBody = "{\"prop1\":\"abc\",\"prop2\":null,\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":1}"; DomainEventSub result = instance.deserialize(eventBody, DomainEventSub.class); assertThat(result.getOccurredOn(), is(event.getOccurredOn())); assertThat(result.getProp1(), is(event.getProp1())); assertThat(result.getVersion(), is(event.getVersion())); assertNull(result.getProp2()); }
@Test public void addDeserializationExclusionStrategy() { builder = builder.addDeserializationExclusionStrategy(new FieldNameExclusionStrategy("version")); instance = builder.build(); String eventBody = "{\"prop1\":\"abc\",\"lastModified\":\"2002-12-11\",\"id\":\"anId\",\"occurredOn\":\"2002-04-11\",\"version\":100}"; DomainEventSub result = instance.deserialize(eventBody, DomainEventSub.class); assertThat(result.getOccurredOn(), is(DateUtils.date(2002, 4, 11))); assertThat(result.getLastModified(), is(DateUtils.date(2002, 12, 11))); assertThat(result.getProp1(), is("abc")); assertNull(result.getProp2()); assertThat(result.getId(), is("anId")); assertThat(result.getVersion(), is(not(100))); } |
EntityRepositoryJpa implements EntityRepository { @Override public String getQueryStringOfNamedQuery(String queryName) { return getNamedQueryParser().getQueryStringOfNamedQuery(queryName); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGetQueryStringOfNamedQuery() { NamedQueryParser namedQueryParser = mock(NamedQueryParser.class); repository.setNamedQueryParser(namedQueryParser); when(namedQueryParser.getQueryStringOfNamedQuery("Dictionay.findNameAndOrder")) .thenReturn("select o.code, o.text from Dictionary o where o.category = :category"); assertEquals("select o.code, o.text from Dictionary o where o.category = :category", repository.getQueryStringOfNamedQuery("Dictionay.findNameAndOrder")); } |
DateRange implements Serializable { public boolean contains(Date date) { return (date.after(from) || DateUtils.isSameDay(date, from)) && (date.before(to) || DateUtils.isSameDay(date, to)); } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testContains() throws ParseException { Date date = DateUtils.parseDate("2007-12-05 04:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertTrue(range.contains(date)); date = DateUtils.parseDate("2007-12-15 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertTrue(range.contains(date)); date = DateUtils.parseDate("2007-12-10 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertTrue(range.contains(date)); date = DateUtils.parseDate("2007-11-10 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertFalse(range.contains(date)); date = DateUtils.parseDate("2008-11-10 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); assertFalse(range.contains(date)); } |
DateRange implements Serializable { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof DateRange)) { return false; } DateRange that = (DateRange) other; return DateUtils.isSameDay(this.from, that.from) && DateUtils.isSameDay(this.to, that.to); } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testEqualsObject() throws ParseException { DateRange range1 = new DateRange( DateUtils.parseDate("2007-12-05 04:10:15", new String[] {"yyyy-M-d hh:mm:ss"}), DateUtils.parseDate("2007-12-15 23:11:15", new String[] {"yyyy-M-d hh:mm:ss"})); assertEquals(range1, range); range1 = new DateRange( DateUtils.parseDate("2007-12-6 11:29:15", new String[] {"yyyy-M-d hh:mm:ss"}), DateUtils.parseDate("2007-12-15 11:11:15", new String[] {"yyyy-M-d hh:mm:ss"})); assertFalse(range1.equals(range)); range1 = new DateRange( DateUtils.parseDate("2007-12-5 11:29:15", new String[] {"yyyy-M-d hh:mm:ss"}), DateUtils.parseDate("2007-12-16 11:11:15", new String[] {"yyyy-M-d hh:mm:ss"})); assertFalse(range1.equals(range)); } |
DateRange implements Serializable { @Override public String toString() { return "[" + DateFormat.getDateInstance().format(from) + " - " + DateFormat.getDateInstance().format(to) + "]"; } DateRange(Date from, Date to); Date getFrom(); Date getTo(); boolean contains(Date date); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); } | @Test public void testToString() throws ParseException { Date from = DateUtils.parseDate("2007-12-05 04:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); Date to = DateUtils.parseDate("2007-12-15 23:10:15", new String[] {"yyyy-M-d hh:mm:ss"}); String fromString = DateFormat.getDateInstance().format(from); String toString = DateFormat.getDateInstance().format(to); assertEquals("[" + fromString + " - " + toString + "]", range.toString()); } |
BeanUtils { public Map<String, Class<?>> getPropTypes() { return beanClassUtils.getPropTypes(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testGetPropTypes() { Map<String, Class<?>> types = instance.getPropTypes(); assertEquals(int.class, types.get("id")); assertEquals(String.class, types.get("name")); assertEquals(boolean.class, types.get("disabled")); assertEquals(double.class, types.get("price")); } |
BeanUtils { public Map<String, Object> getPropValues() { return getPropValues(getReadablePropNames()); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testGetPropValues() { Map<String, Object> values = instance.getPropValues(); assertEquals(1, values.get("id")); assertEquals("abc", values.get("name")); assertNull(values.get("disabled")); assertEquals(12.5, (Double) values.get("price"), 0.001); } |
BeanUtils { public Set<String> getPropNames() { return beanClassUtils.getPropNames(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testGetPropNames() { assertTrue(instance.getPropNames().containsAll( Arrays.asList("id", "price", "name", "disabled"))); } |
BeanUtils { public Set<String> getReadablePropNames() { return beanClassUtils.getReadablePropNames(); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testGetReadablePropNames() { Set<String> results = instance.getReadablePropNames(); assertTrue(results.containsAll( Arrays.asList("id", "price", "name"))); assertFalse(results.contains("disabled")); } |
BeanUtils { public Map<String, Object> getPropValuesExclude(String... excludePropNames) { return getPropValues(beanClassUtils.getReadablePropNamesExclude(excludePropNames)); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testGetPropValuesExcludeName() { Map<String, Object> values = instance.getPropValuesExclude("id"); assertFalse(values.containsKey("id")); assertEquals("abc", values.get("name")); assertNull(values.get("disabled")); assertEquals(12.5, (Double) values.get("price"), 0.001); }
@Test public void testGetPropValuesExcludeAnnotation() { Map<String, Object> values = instance.getPropValuesExclude(Deprecated.class); assertEquals(1, values.get("id")); assertEquals("abc", values.get("name")); assertNull(values.get("disabled")); assertFalse(values.containsKey("price")); } |
EntityRepositoryJpa implements EntityRepository { @Override public void flush() { getEntityManager().flush(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFlush() { String description = "Ha Ha Ha!"; male.setDescription(description); repository.flush(); Dictionary male1 = repository.get(Dictionary.class, male.getId()); assertEquals(description, male1.getDescription()); } |
BeanUtils { public Object getPropValue(String propName) { try { PropertyDescriptor propertyDescriptor = beanClassUtils.getPropertyDescriptors().get(propName); Method readMethod = propertyDescriptor.getReadMethod(); if (readMethod == null) { return null; } return readMethod.invoke(bean, new Object[]{}); } catch (Exception e) { throw new RuntimeException(e); } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testGetPropValue() { assertEquals("abc", instance.getPropValue("name")); } |
BeanUtils { public void setPropValue(String key, Object value) { for (Map.Entry<String, PropertyDescriptor> entry : beanClassUtils.getPropertyDescriptors().entrySet()) { if (!entry.getKey().equals(key)) { continue; } PropertyDescriptor propertyDescriptor = entry.getValue(); Method writeMethod = propertyDescriptor.getWriteMethod(); if (writeMethod == null) { continue; } try { writeMethod.invoke(bean, value); } catch (Exception ex) { } } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testSetPropValue() { instance.setPropValue("id", 1000); assertEquals(1, item.getId()); instance.setPropValue("price", 2015); assertEquals(2015, item.getPrice(), 0.0001); } |
BeanUtils { public void populate(Map<String, ? extends Object> properties) { for (Map.Entry<String, ? extends Object> entry : properties.entrySet()) { setPropValue(entry.getKey(), entry.getValue()); } } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testPopulateWithMap() { Map<String, Object> properties = new HashMap<String, Object>(); properties.put("id", 1000); properties.put("name", "aaaa"); instance.populate(properties); assertEquals(1, item.getId()); assertEquals("aaaa", item.getName()); assertEquals(12.5, item.getPrice(), 0.0001); } |
BeanUtils { public void copyPropertiesFrom(Object otherBean) { copyProperties(otherBean, bean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testCopyPropertiesFrom() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesFrom(item1); assertEquals("abc", item2.getName()); assertEquals(15.5, item2.getPrice(), 0.0001); }
@Test public void testCopyPropertiesFromWithExcludes() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesFrom(item1, "id"); assertEquals(20, item2.getId()); assertEquals("abc", item2.getName()); assertEquals(15.5, item2.getPrice(), 0.0001); } |
BeanUtils { public void copyPropertiesTo(Object otherBean) { copyProperties(bean, otherBean); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testCopyPropertiesTo() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesTo(item1); assertEquals("xyz", item1.getName()); }
@Test public void testCopyPropertiesToWithExcludes() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); instance.copyPropertiesTo(item1, "id"); assertEquals(20, item2.getId()); assertEquals("xyz", item1.getName()); } |
BeanUtils { public PropertyInfo getPropInfo(String propName) { return getPropInfos().get(propName); } BeanUtils(final Object bean); Map<String, Class<?>> getPropTypes(); Class<?> getPropType(String propName); Map<String, Object> getPropValues(); Map<String, Object> getPropValuesExclude(String... excludePropNames); Map<String, Object> getPropValuesExclude(Class<? extends Annotation>... excludeAnnotations); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Object getPropValue(String propName); void setPropValue(String key, Object value); void populate(Map<String, ? extends Object> properties); void copyPropertiesFrom(Object otherBean); void copyPropertiesTo(Object otherBean); void copyPropertiesFrom(Object otherBean, String... excludeProps); void copyPropertiesTo(Object otherBean, String... excludeProps); Map<String, PropertyInfo> getPropInfos(); PropertyInfo getPropInfo(String propName); } | @Test public void testGetPropertyInfos() { Item item1 = new Item(12, "abc", true); ConcreteItem item2 = new ConcreteItem(20, "xyz", false); item2.setPrice(15.5); instance = new BeanUtils(item2); assertEquals(new PropertyInfo("id", int.class, 20), instance.getPropInfo("id")); assertEquals(new PropertyInfo("name", String.class, "xyz"), instance.getPropInfo("name")); assertEquals(new PropertyInfo("price", double.class, 15.5), instance.getPropInfo("price")); } |
ArrayUtils { public static Object[] substract(Object[] items, String property) { Assert.notNull(items); Assert.notBlank(property, "property name must not empty!"); if (items.length == 0) { return new Object[0]; } Object[] results = new Object[items.length]; for (int i = 0; i < items.length; i++) { Object item = items[i]; Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results[i] = propValues.get(property); } return results; } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); } | @Test public void testSubstract() { Item[] items = { new Item(1, "A"), new Item(2, "B"), new Item(1, "C") }; assertArrayEquals(new Object[]{1, 2, 1}, ArrayUtils.substract(items, "id")); assertArrayEquals(new Object[]{"A", "B", "C"}, ArrayUtils.substract(items, "name")); }
@Test public void testSubstractEmpty() { assertEquals(ArrayUtils.substract(new Item[]{}, "name").length, 0); }
@Test public void testSubstractSingleElement() { Item[] items = { new Item(1, "A") }; assertArrayEquals(new Object[]{1}, ArrayUtils.substract(items, "id")); }
@Test(expected = IllegalArgumentException.class) public void testPropertyNotExists() { Item[] items = { new Item(1, "A"), new Item(2, "B"), new Item(1, "C") }; ArrayUtils.substract(items, "birthday"); } |
EntityRepositoryJpa implements EntityRepository { @Override public void refresh(Entity entity) { getEntityManager().refresh(entity); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testRefresh() { String text = "Ha Ha Ha!"; male.setText(text); repository.refresh(male); assertEquals("男", male.getText()); } |
ArrayUtils { public static String join(Object[] items, String property, String separator) { if (items == null || items.length == 0) { return ""; } return StringUtils.join(substract(items, property), separator); } private ArrayUtils(); static Object[] substract(Object[] items, String property); static String join(Object[] items, String property, String separator); } | @Test public void testJoin() { Item[] items = { new Item(1, "A"), new Item(2, "B"), new Item(1, "C") }; String separator = ", "; String result = ArrayUtils.join(items, "id", separator); assertEquals("1, 2, 1", result); }
@Test public void testJoinNull() { String separator = ", "; Item[] items = null; String result = ArrayUtils.join(items, "id", separator); assertTrue(result.isEmpty()); }
@Test public void testJoinEmpty() { Item[] items = {}; String separator = ", "; String result = ArrayUtils.join(items, "id", separator); assertTrue(result.isEmpty()); }
@Test public void testJoinSingleElement() { Item[] items = { new Item(1, "A") }; String separator = ", "; String result = ArrayUtils.join(items, "name", separator); assertEquals("A", result); } |
DateUtils { public static Date date(int year, int month, int day) { Calendar calendar = Calendar.getInstance(); calendar.set(year, month - 1, day, 0, 0, 0); calendar.set(Calendar.MILLISECOND, 0); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testDate() throws ParseException { assertEquals(DateUtils.date(1968, 4, 11), org.apache.commons.lang3.time.DateUtils.parseDate("1968-04-11", "yyyy-MM-dd")); } |
DateUtils { public static int getYearDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int result = year2 - year1; if (month2 < month1) { result--; } else if (month2 == month1 && day2 < day1) { result--; } return result; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getYearDiff() { assertEquals(2009 - 1968, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-5-1"))); assertEquals(2009 - 1968 - 1, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-3-20"))); assertEquals(2009 - 1968, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-4-17"))); assertEquals(2009 - 1968, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-4-16"))); assertEquals(2009 - 1968 - 1, DateUtils.getYearDiff(parseDate("1968-4-16"), parseDate("2009-4-15"))); } |
DateUtils { public static int getMonthDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } if (date1.after(date2)) { throw new InvalidParameterException("date1 cannot be after date2!"); } Calendar calendar = Calendar.getInstance(); calendar.setTime(date1); int year1 = calendar.get(Calendar.YEAR); int month1 = calendar.get(Calendar.MONTH); int day1 = calendar.get(Calendar.DATE); calendar.setTime(date2); int year2 = calendar.get(Calendar.YEAR); int month2 = calendar.get(Calendar.MONTH); int day2 = calendar.get(Calendar.DATE); int months = 0; if (day2 >= day1) { months = month2 - month1; } else { months = month2 - month1 - 1; } return (year2 - year1) * MONTHS_IN_A_YEAR + months; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getMonthDiff() { assertEquals(0, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-4-30"))); assertEquals(0, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-5-15"))); assertEquals(1, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-5-16"))); assertEquals(1, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-5-17"))); assertEquals(2, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1968-6-16"))); assertEquals(24, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-4-30"))); assertEquals(24, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-5-15"))); assertEquals(25, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-5-16"))); assertEquals(25, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-5-17"))); assertEquals(26, DateUtils.getMonthDiff(parseDate("1968-4-16"), parseDate("1970-6-16"))); } |
EntityRepositoryJpa implements EntityRepository { @Override public void clear() { getEntityManager().clear(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testClear() { repository.clear(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.