id
stringlengths 8
13
| source
stringlengths 164
33.1k
| target
stringlengths 36
5.98k
|
|---|---|---|
11383343_1
|
class MyAction extends ActionSupport {
public String save() {
System.out.println(id);
System.out.println(name);
return SUCCESS;
}
public String getId();
public void setId(String id);
public String getName();
public void setName(String name);
public String view();
public static final Logger LOG;
}
class TestMyAction extends ActionSupport {
public static final Logger LOG;
@Test
public void testSave() throws Exception {
|
// request.setParameter("id", "1");
// request.setParameter("name", "Test Desc");
request.setContent("{\"id\":\"1\",\"name\":\"nitin\"}".getBytes());
// request.setContentType("application/json");
request.addHeader("Content-Type", "application/json");
// request.setContent("{id:1,name:nitin}".getBytes());
request.setMethod("POST");
// request.set
ActionProxy proxy = getActionProxy("/save");
actions.MyAction myAct = (actions.MyAction) proxy.getAction();
String result = proxy.execute();
System.out.println("test id : " + myAct.getId());
System.out.println("test name : " + myAct.getName());
assertEquals("success", result);
// System.out.println(ToStringBuilder.reflectionToString(response));
System.out.println(response.getContentAsString());
}
}
|
11585818_2
|
class Sampling {
public static Sampling valueOf(String samplerName) {
if ("off".equalsIgnoreCase(samplerName)) return OFF;
if ("on".equalsIgnoreCase(samplerName)) return ON;
return null;
}
public abstract boolean trace();
}
class SamplingTest {
@Test
public void testSamplingValueOfString() {
|
assertNull(Sampling.valueOf(null));
assertNull(Sampling.valueOf("unknown"));
assertEquals(Sampling.ON, Sampling.valueOf("on"));
assertEquals(Sampling.ON, Sampling.valueOf("ON"));
assertEquals(Sampling.ON, Sampling.valueOf("oN"));
assertEquals(Sampling.OFF, Sampling.valueOf("off"));
assertEquals(Sampling.OFF, Sampling.valueOf("OFF"));
assertEquals(Sampling.OFF, Sampling.valueOf("oFf"));
}
}
|
11585818_4
|
class AsynchronousSpanSink implements SpanSink {
@Override
public void record(SpanData spanData) {
Runnable job = jobFactory.createJob(spanData);
executor.execute(job);
}
public AsynchronousSpanSink(JobFactory jobFactory);
public AsynchronousSpanSink(ExecutorService executor, JobFactory jobFactory);
public int shutdown(long timeout, TimeUnit timeunit);
}
class AsynchronousSpanSinkTest {
@Test
public void testSubmitsExpectedRecordTasksToExecutor() {
|
ExecutorService executor = mock(ExecutorService.class);
AsynchronousSpanSink.JobFactory jobFactory = mock(AsynchronousSpanSink.JobFactory.class);
SpanSink sink = new AsynchronousSpanSink(executor, jobFactory);
SpanData spanData = new BeanSpanData();
Runnable runnable = new Runnable() {
@Override
public void run() {
}
};
when(jobFactory.createJob(eq(spanData))).thenReturn(runnable);
sink.record(spanData);
verify(jobFactory).createJob(eq(spanData));
verify(executor).execute(eq(runnable));
}
}
|
11614244_0
|
class RawImageReader {
public String getDcrawBin() {
// Check field
if (dcrawBin != null) {
return dcrawBin;
}
// Check environment
String dcrawEnv = System.getenv().get(DCRAW_ENV_VAR);
if (dcrawEnv != null) {
return dcrawEnv;
}
// Guess by OS
if (System.getProperty("os.name").startsWith("Windows")) {
return "dcraw.exe";
} else {
return "dcraw";
}
}
public RawImageReader();
public RawImageReader(String dcrawBin);
public BufferedImage read(final String file, final List<String> params);
public boolean canDecode(final String file);
}
class RawImageReaderTest {
@Test
public void dgetDcrawBin_var() {
|
RawImageReader r = new RawImageReader("test-path");
String dcrawBin = r.getDcrawBin();
assertEquals("test-path", dcrawBin);
}
}
|
11614244_1
|
class ParameterReader {
public List<String> readParameters(final String baseKey, final boolean otherRaw) {
if (otherRaw) {
return readParameters(baseKey + RAW_KEY);
} else {
return readParameters(baseKey + NON_RAW_KEY);
}
}
private List<String> readParameters(final String key);
private Properties getProperties();
}
class ParameterReaderTest {
@Test
public void readParameters_invalidBasekey() {
|
ParameterReader pr = new ParameterReader();
List<String> expectedRaw = new ArrayList<String>();
List<String> paramsRaw = pr.readParameters("invalid.key", true);
assertThat(paramsRaw, is(expectedRaw));
List<String> expectedNonRaw = new ArrayList<String>();
List<String> paramsNonRaw = pr.readParameters("invalid.key", false);
assertThat(paramsNonRaw, is(expectedNonRaw));
}
}
|
11614244_2
|
class ParameterReader {
public List<String> readParameters(final String baseKey, final boolean otherRaw) {
if (otherRaw) {
return readParameters(baseKey + RAW_KEY);
} else {
return readParameters(baseKey + NON_RAW_KEY);
}
}
private List<String> readParameters(final String key);
private Properties getProperties();
}
class ParameterReaderTest {
@Test
public void readParameters_basekey1() {
|
ParameterReader pr = new ParameterReader();
List<String> expectedRaw = Arrays.asList("-6");
List<String> paramsRaw = pr.readParameters("key1", true);
assertThat(paramsRaw, is(expectedRaw));
List<String> expectedNonRaw = Arrays.asList("-6", "-T", "-o", "1", "-w");
List<String> paramsNonRaw = pr.readParameters("key1", false);
assertThat(paramsNonRaw, is(expectedNonRaw));
}
}
|
11614244_7
|
class ScaleToNearestFactorPreprocessor extends ScalePreprocessor {
@Override
public void process() {
if (widthFactor1 < THRESHOLD || heightFactor1 < THRESHOLD || widthFactor2 < THRESHOLD ||
heightFactor2 < THRESHOLD) {
LOGGER.info("Scaling image with factors [{}], [{}]", widthFactor1, heightFactor1);
super.process();
} else {
LOGGER.info("All scale factors [{}], [{}], [{}], [{}] are above threshold [{}]", widthFactor1,
heightFactor1, widthFactor2, heightFactor2, THRESHOLD);
result1 = img1;
result2 = img2;
}
}
public ScaleToNearestFactorPreprocessor(final BufferedImage img1, final BufferedImage img2, int targetSize);
private static double calcScaleFactor(final BufferedImage img, final int targetSize);
}
class ScaleToNearestFactorPreprocessorTest {
@Test
public void executeTest_equalSize() {
|
BufferedImage img1 = BufferedImageHelper.createSolidImage(new Color(0, 0, 0));
BufferedImage img2 = BufferedImageHelper.createSolidImage(new Color(0, 0, 0));
ScaleToNearestFactorPreprocessor pp = new ScaleToNearestFactorPreprocessor(img1, img2, 500);
pp.process();
Assert.assertEquals(img1, pp.getResult1());
Assert.assertEquals(img2, pp.getResult2());
}
}
|
11614244_8
|
class ScaleToNearestFactorPreprocessor extends ScalePreprocessor {
@Override
public void process() {
if (widthFactor1 < THRESHOLD || heightFactor1 < THRESHOLD || widthFactor2 < THRESHOLD ||
heightFactor2 < THRESHOLD) {
LOGGER.info("Scaling image with factors [{}], [{}]", widthFactor1, heightFactor1);
super.process();
} else {
LOGGER.info("All scale factors [{}], [{}], [{}], [{}] are above threshold [{}]", widthFactor1,
heightFactor1, widthFactor2, heightFactor2, THRESHOLD);
result1 = img1;
result2 = img2;
}
}
public ScaleToNearestFactorPreprocessor(final BufferedImage img1, final BufferedImage img2, int targetSize);
private static double calcScaleFactor(final BufferedImage img, final int targetSize);
}
class ScaleToNearestFactorPreprocessorTest {
@Test
public void executeTest_ltSize() {
|
BufferedImage img1 = BufferedImageHelper.createSolidImage(new Color(0, 0, 0));
BufferedImage img2 = BufferedImageHelper.createSolidImage(new Color(0, 0, 0));
ScaleToNearestFactorPreprocessor pp = new ScaleToNearestFactorPreprocessor(img1, img2,
BufferedImageHelper.DEFAULT_WIDTH /
2);
pp.process();
Assert.assertEquals(BufferedImageHelper.DEFAULT_WIDTH / 2, pp.getResult1().getWidth());
Assert.assertEquals(BufferedImageHelper.DEFAULT_HEIGHT / 2, pp.getResult1().getHeight());
Assert.assertEquals(BufferedImageHelper.DEFAULT_WIDTH / 2, pp.getResult2().getWidth());
Assert.assertEquals(BufferedImageHelper.DEFAULT_HEIGHT / 2, pp.getResult2().getHeight());
}
}
|
11614244_9
|
class ScaleToNearestFactorPreprocessor extends ScalePreprocessor {
@Override
public void process() {
if (widthFactor1 < THRESHOLD || heightFactor1 < THRESHOLD || widthFactor2 < THRESHOLD ||
heightFactor2 < THRESHOLD) {
LOGGER.info("Scaling image with factors [{}], [{}]", widthFactor1, heightFactor1);
super.process();
} else {
LOGGER.info("All scale factors [{}], [{}], [{}], [{}] are above threshold [{}]", widthFactor1,
heightFactor1, widthFactor2, heightFactor2, THRESHOLD);
result1 = img1;
result2 = img2;
}
}
public ScaleToNearestFactorPreprocessor(final BufferedImage img1, final BufferedImage img2, int targetSize);
private static double calcScaleFactor(final BufferedImage img, final int targetSize);
}
class ScaleToNearestFactorPreprocessorTest {
@Test
public void executeTest_equalSize_gtSize() {
|
BufferedImage img1 = BufferedImageHelper.createSolidImage(new Color(0, 0, 0), 400, 200);
BufferedImage img2 = BufferedImageHelper.createSolidImage(new Color(0, 0, 0), 100, 50);
ScaleToNearestFactorPreprocessor pp = new ScaleToNearestFactorPreprocessor(img1, img2, 200);
pp.process();
Assert.assertEquals(400, pp.getResult1().getWidth());
Assert.assertEquals(200, pp.getResult1().getHeight());
Assert.assertEquals(100, pp.getResult2().getWidth());
Assert.assertEquals(50, pp.getResult2().getHeight());
}
}
|
11919447_0
|
class QueryController {
int skipToLast(int cursorLength, int limit)
{
if (cursorLength > limit)
{
return cursorLength - limit;
}
return 0;
}
@Secured(Roles.ROLE_ADMIN) @RequestMapping(value = "/{collection}/{id}", method = RequestMethod.DELETE) public ResponseEntity<?> deleteDocument(@PathVariable("collection") String collection,
@PathVariable("id") String id);
private void dropWholeCollection(String collection);
@RequestMapping(value = "/{collection}/{id}", method = RequestMethod.GET) public ResponseEntity<String> find(
@PathVariable("collection") String collection,
@PathVariable("id") String id);
@RequestMapping(value = "/{collection}/", method = RequestMethod.GET) @ResponseBody public ResponseEntity<String> find(
@PathVariable("collection") String collection,
@RequestParam(value = "version", required = false) String version,
@RequestParam(value = "category", required = false) String category,
@RequestParam(value = "limit", required = false) String limit,
@RequestParam(value = "skip", required = false) String skip,
@RequestParam(value = "sort", required = false) String sort,
@RequestParam(value = "last", required = false) String last);
private DBCursor getDbCursor(final String collection, final String version, final String category);
private void skipElements(final String collection, final String skipValue, final String last, final DBCursor dbData);
private void limitResult(final String limitValue, final DBCursor dbData);
private void sortResult(final String sort, final DBCursor dbData);
}
class QueryControllerTest {
@Test(dataProvider = "computeNumberOfSkips")
public void last_ten_with_list_nine(int cursorLength, int lastNrOfDocuments, int expectedNrOfSkips)
{
|
QueryController queryController = new QueryController();
int actualNrOfSkips = queryController.skipToLast(cursorLength, lastNrOfDocuments);
assertEquals(actualNrOfSkips, expectedNrOfSkips);
}
}
|
11919447_1
|
class MimeTypeToExtensionsUtil {
public static String getExtension(final String mimeType)
{
if (MIME_TYPES_EXTENSIONS.containsKey(mimeType))
{
return MIME_TYPES_EXTENSIONS.get(mimeType);
}
return mimeType.substring(mimeType.indexOf("/") + 1);
}
}
class MimeTypeToExtensionsUtilTest {
@Test
public void mapApplicationZipToZip()
{
|
String extension = MimeTypeToExtensionsUtil.getExtension("application/zip");
Assert.assertEquals("zip", extension);
}
}
|
11919447_2
|
class MimeTypeToExtensionsUtil {
public static String getExtension(final String mimeType)
{
if (MIME_TYPES_EXTENSIONS.containsKey(mimeType))
{
return MIME_TYPES_EXTENSIONS.get(mimeType);
}
return mimeType.substring(mimeType.indexOf("/") + 1);
}
}
class MimeTypeToExtensionsUtilTest {
@Test
public void mapImagePngToPng()
{
|
String extension = MimeTypeToExtensionsUtil.getExtension("image/png");
Assert.assertEquals("png", extension);
}
}
|
11919447_3
|
class MimeTypeToExtensionsUtil {
public static String getExtension(final String mimeType)
{
if (MIME_TYPES_EXTENSIONS.containsKey(mimeType))
{
return MIME_TYPES_EXTENSIONS.get(mimeType);
}
return mimeType.substring(mimeType.indexOf("/") + 1);
}
}
class MimeTypeToExtensionsUtilTest {
@Test
public void mapImageJpegToJpg()
{
|
String extension = MimeTypeToExtensionsUtil.getExtension("image/jpeg");
Assert.assertEquals("jpg", extension);
}
}
|
11919447_4
|
class MimeTypeToExtensionsUtil {
public static String getExtension(final String mimeType)
{
if (MIME_TYPES_EXTENSIONS.containsKey(mimeType))
{
return MIME_TYPES_EXTENSIONS.get(mimeType);
}
return mimeType.substring(mimeType.indexOf("/") + 1);
}
}
class MimeTypeToExtensionsUtilTest {
@Test
public void mapTextPlainToLog()
{
|
String extension = MimeTypeToExtensionsUtil.getExtension("text/plain");
Assert.assertEquals("log", extension);
}
}
|
13040953_0
|
class License {
public static License findByValue(final String uri) {
License found = License.lookupLicense.get(uri);
// No I am going to try an guess about unknown licenses
// This is try and match known CC licenses of other versions or various URLs to
// current licenses, then make a new one with the same permissions.
if (found == null && uri.startsWith("http://") && uri.toLowerCase().indexOf("creativecommons.org") != -1) {
final Iterator<String> it = License.lookupLicense.keySet().iterator();
while (it.hasNext() && found == null) {
final String key = it.next();
try {
if (key.startsWith(CC_START)) {
final String licensePath = key.substring(CC_START.length(), key.length());
final StringTokenizer tok = new StringTokenizer(licensePath, "/");
final String license = tok.nextToken();
// final String version = tok.nextToken();
if (uri.toLowerCase().indexOf("creativecommons.org/licenses/" + license) != -1) {
final License current = lookupLicense.get(key);
found = new License(uri, current.getRequires(), current.getPermits());
}
}
} catch (final Exception e) {
LOG.error("Error", e);
}
}
}
// OK, we got here. If we haven't found a match, return a new License with unknown
// permissions.
if (found == null) {
found = new License(uri, null, null);
}
return found;
}
public License(final String uri, final Behaviour[] requires, final Behaviour[] permits);
static void clear();
public Behaviour[] getPermits();
public Behaviour[] getRequires();
@Override public String toString();
public String getValue();
@Override public boolean equals(final Object obj);
@Override public int hashCode();
private static final Logger LOG;
}
class LicenseTest {
private static final Logger LOG;
@Test(timeout = 1000)
public void testConcurrent() throws InterruptedException {
|
final AtomicBoolean run = new AtomicBoolean(true);
final AtomicLong type = new AtomicLong(0);
// Tracking any problems.
final AtomicBoolean hadProblem = new AtomicBoolean(false);
final AtomicBoolean hadException = new AtomicBoolean(false);
// This thread keeps on adding new licenses (not very realistic but shows the bug)
final Thread addNew = new Thread() {
@Override
public void run() {
try {
while (run.get()) {
final License license = License.findByValue("http://creativecommons.org/licenses/" + type.incrementAndGet() + "/1");
if (license == null) {
hadProblem.set(true);
}
}
} catch (final Exception e) {
LOG.error("Exception in add-new thread", e);
hadException.set(true);
}
}
};
// This thread attempts to get ones we know have already been put in.
final Thread getExisting = new Thread() {
@Override
public void run() {
final Random rnd = new Random();
try {
while (run.get()) {
if (type.intValue() == 0) {
continue;
}
final License license = License.findByValue("http://creativecommons.org/licenses/" + rnd.nextInt(type.intValue()) + "/1");
if (license == null) {
hadProblem.set(true);
}
}
} catch (final Exception e) {
LOG.error("Exception in get-existing thread", e);
hadException.set(true);
}
}
};
addNew.start();
getExisting.start();
// Let them do some stuff.
Thread.sleep(400);
// Get them to both stop.
run.set(false);
// Allow them a little time to stop.
addNew.join(50);
getExisting.join(50);
// Check we didn't have any problems and they have both stopped.
assertFalse(hadProblem.get());
assertFalse(hadException.get());
assertFalse(addNew.isAlive());
assertFalse(getExisting.isAlive());
}
}
|
13040953_1
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog() throws IOException {
|
final InputStream input = stringToStream("<?xml encoding=\"TEST\"?>", "UTF-8");
final String guessedEncoding = "UTF-8";
final String prologEncoding = XmlReader.getXmlProlog(input, guessedEncoding);
assertEquals("TEST", prologEncoding);
}
}
|
13040953_2
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog_Utf8() throws IOException {
|
final InputStream input = stringToStream("<?xml encoding=\"UTF-8\"?>", "UTF-8");
final String guessedEncoding = "UTF-8";
final String prologEncoding = XmlReader.getXmlProlog(input, guessedEncoding);
assertEquals("UTF-8", prologEncoding);
}
}
|
13040953_3
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog_Utf16() throws IOException {
|
final InputStream input = stringToStream("<?xml encoding=\"UTF-16\"?>", "UTF-16");
final String guessedEncoding = "UTF-16";
assertEquals("UTF-16", XmlReader.getXmlProlog(input, guessedEncoding));
}
}
|
13040953_4
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog_Cp1047() throws IOException {
|
final InputStream input = stringToStream("<?xml encoding=\"CP1047\"?>", "CP1047");
final String guessedEncoding = "CP1047";
assertEquals("CP1047", XmlReader.getXmlProlog(input, guessedEncoding));
}
}
|
13040953_5
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog_NoEncoding() throws IOException {
|
final InputStream input = stringToStream("<?xml>", "UTF-8");
final String guessedEncoding = "UTF-8";
assertNull(XmlReader.getXmlProlog(input, guessedEncoding));
}
}
|
13040953_6
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog_GuessedIsNull() throws IOException {
|
final InputStream input = stringToStream("<?xml encoding=\"UTF-8\"?>", "UTF-8");
final String guessedEncoding = null;
assertNull(XmlReader.getXmlProlog(input, guessedEncoding));
}
}
|
13040953_7
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog_UppercaseResult() throws IOException {
|
final InputStream input = stringToStream("<?xml encoding=\"utf-8\"?>", "UTF-8");
final String guessedEncoding = "UTF-8";
assertEquals("UTF-8", XmlReader.getXmlProlog(input, guessedEncoding));
}
}
|
13040953_8
|
class XmlReader extends Reader {
static String getXmlProlog(final InputStream is, final String guessedEnc) throws IOException {
String encoding = null;
if (guessedEnc != null) {
final byte[] bytes = new byte[BUFFER_SIZE];
is.mark(BUFFER_SIZE);
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read(bytes, offset, max);
int firstGT = -1;
while (c != -1 && firstGT == -1 && offset < BUFFER_SIZE) {
offset += c;
max -= c;
c = is.read(bytes, offset, max);
firstGT = new String(bytes, 0, offset, guessedEnc).indexOf(">");
}
if (firstGT == -1) {
if (c == -1) {
throw new IOException("Unexpected end of XML stream");
} else {
throw new IOException("XML prolog or ROOT element not found on first " + offset + " bytes");
}
}
final int bytesRead = offset;
if (bytesRead > 0) {
is.reset();
String prolog = new String(bytes, guessedEnc).substring(0, firstGT);
final Matcher m = ENCODING_PATTERN.matcher(prolog);
if (m.find()) {
encoding = m.group(1).toUpperCase(Locale.ENGLISH);
encoding = encoding.substring(1, encoding.length() - 1);
}
}
}
return encoding;
}
public XmlReader(final File file);
public XmlReader(final InputStream is);
public XmlReader(final InputStream is, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final boolean lenient);
public XmlReader(final URL url);
public XmlReader(final URL url, final Map<String, String> requestHeaders);
public XmlReader(final URLConnection conn);
public XmlReader(final URLConnection conn, final Map<String, String> requestHeaders);
public XmlReader(final InputStream is, final String httpContentType);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient, final String defaultEncoding);
public XmlReader(final InputStream is, final String httpContentType, final boolean lenient);
public static String getDefaultEncoding();
public static void setDefaultEncoding(final String encoding);
public String getEncoding();
private void doLenientDetection(String httpContentType, XmlReaderException ex);
@Override public int read(final char[] buf, final int offset, final int len);
@Override public void close();
private void doRawStream(final InputStream is, final boolean lenient);
private void doHttpStream(final InputStream is, final String httpContentType, final boolean lenient);
private void prepareReader(final InputStream is, final String encoding);
private String calculateRawEncoding(final String bomEnc, final String xmlGuessEnc, final String xmlEnc, final InputStream is);
private void setRequestHeader(final URLConnection conn, final Map<String, String> requestHeaders);
private String calculateHttpEncoding(final String cTMime, final String cTEnc, final String bomEnc, final String xmlGuessEnc, final String xmlEnc,
final InputStream is, final boolean lenient);
private static String getContentTypeMime(final String httpContentType);
private static String getContentTypeEncoding(final String httpContentType);
private static String getBOMEncoding(final BufferedInputStream is);
private static String getXMLGuessEncoding(final BufferedInputStream is);
private static boolean isAppXml(final String mime);
private static boolean isTextXml(final String mime);
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
}
class XmlReaderTest {
private static final String XML5;
private static final String XML4;
private static final String XML3;
private static final String XML2;
private static final String XML1;
@Rule
public ExpectedException expectedException;
private static final String ENCODING_ATTRIBUTE_XML;
private static final int[] NO_BOM_BYTES;
private static final int[] UTF_16BE_BOM_BYTES;
private static final int[] UTF_16LE_BOM_BYTES;
private static final int[] UTF_8_BOM_BYTES;
private static final Map<String, int[]> BOMs;
private static final MessageFormat XML;
private static final MessageFormat XML_WITH_PROLOG;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_DOUBLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SINGLE_QUOTES;
private static final MessageFormat XML_WITH_PROLOG_AND_ENCODING_SPACED_SINGLE_QUOTES;
private static final MessageFormat INFO;
private static final Map<String, MessageFormat> XMLs;
@Test
public void testGetXmlProlog_DifferentAsciiCompatible() throws IOException {
|
final InputStream input = stringToStream("<?xml encoding=\"TEST\"?>", "ISO-8859-1");
final String guessedEncoding = "UTF-8";
assertEquals("TEST", XmlReader.getXmlProlog(input, guessedEncoding));
}
}
|
14892248_0
|
class XMPMetaParser {
public static XMPMeta parse(Object input, ParseOptions options) throws XMPException
{
ParameterAsserts.assertNotNull(input);
options = options != null ? options : new ParseOptions();
Document document = parseXml(input, options);
boolean xmpmetaRequired = options.getRequireXMPMeta();
Object[] result = new Object[3];
result = findRootNode(document, xmpmetaRequired, result);
if (result != null && result[1] == XMP_RDF)
{
XMPMetaImpl xmp = ParseRDF.parse((Node) result[0]);
xmp.setPacketHeader((String) result[2]);
// Check if the XMP object shall be normalized
if (!options.getOmitNormalization())
{
return XMPNormalizer.process(xmp, options);
}
else
{
return xmp;
}
}
else
{
// no appropriate root node found, return empty metadata object
return new XMPMetaImpl();
}
}
private XMPMetaParser();
private static Document parseXml(Object input, ParseOptions options);
private static Document parseXmlFromInputStream(InputStream stream, ParseOptions options);
private static Document parseXmlFromBytebuffer(ByteBuffer buffer, ParseOptions options);
private static Document parseXmlFromString(String input, ParseOptions options);
private static Document parseInputSource(InputSource source);
private static Object[] findRootNode(Node root, boolean xmpmetaRequired, Object[] result);
private static DocumentBuilderFactory createDocumentBuilderFactory();
private static final String XMP_WITH_XXE;
}
class XMPMetaParserTest {
private static final String XMP_WITH_XXE;
@Test
public void xxeTestFromString() {
|
try {
XMPMetaParser.parse(XMP_WITH_XXE, null);
} catch (XMPException e) {
Assert.assertEquals("Children of resource property element must be XML elements", e.getMessage());
}
}
}
|
14892248_1
|
class XMPMetaParser {
public static XMPMeta parse(Object input, ParseOptions options) throws XMPException
{
ParameterAsserts.assertNotNull(input);
options = options != null ? options : new ParseOptions();
Document document = parseXml(input, options);
boolean xmpmetaRequired = options.getRequireXMPMeta();
Object[] result = new Object[3];
result = findRootNode(document, xmpmetaRequired, result);
if (result != null && result[1] == XMP_RDF)
{
XMPMetaImpl xmp = ParseRDF.parse((Node) result[0]);
xmp.setPacketHeader((String) result[2]);
// Check if the XMP object shall be normalized
if (!options.getOmitNormalization())
{
return XMPNormalizer.process(xmp, options);
}
else
{
return xmp;
}
}
else
{
// no appropriate root node found, return empty metadata object
return new XMPMetaImpl();
}
}
private XMPMetaParser();
private static Document parseXml(Object input, ParseOptions options);
private static Document parseXmlFromInputStream(InputStream stream, ParseOptions options);
private static Document parseXmlFromBytebuffer(ByteBuffer buffer, ParseOptions options);
private static Document parseXmlFromString(String input, ParseOptions options);
private static Document parseInputSource(InputSource source);
private static Object[] findRootNode(Node root, boolean xmpmetaRequired, Object[] result);
private static DocumentBuilderFactory createDocumentBuilderFactory();
private static final String XMP_WITH_XXE;
}
class XMPMetaParserTest {
private static final String XMP_WITH_XXE;
@Test
public void xxeTestFromByteBuffer() {
|
try {
XMPMetaParser.parse(XMP_WITH_XXE.getBytes(), null);
} catch (XMPException e) {
Assert.assertEquals("Children of resource property element must be XML elements", e.getMessage());
}
}
}
|
14892248_2
|
class XMPMetaParser {
public static XMPMeta parse(Object input, ParseOptions options) throws XMPException
{
ParameterAsserts.assertNotNull(input);
options = options != null ? options : new ParseOptions();
Document document = parseXml(input, options);
boolean xmpmetaRequired = options.getRequireXMPMeta();
Object[] result = new Object[3];
result = findRootNode(document, xmpmetaRequired, result);
if (result != null && result[1] == XMP_RDF)
{
XMPMetaImpl xmp = ParseRDF.parse((Node) result[0]);
xmp.setPacketHeader((String) result[2]);
// Check if the XMP object shall be normalized
if (!options.getOmitNormalization())
{
return XMPNormalizer.process(xmp, options);
}
else
{
return xmp;
}
}
else
{
// no appropriate root node found, return empty metadata object
return new XMPMetaImpl();
}
}
private XMPMetaParser();
private static Document parseXml(Object input, ParseOptions options);
private static Document parseXmlFromInputStream(InputStream stream, ParseOptions options);
private static Document parseXmlFromBytebuffer(ByteBuffer buffer, ParseOptions options);
private static Document parseXmlFromString(String input, ParseOptions options);
private static Document parseInputSource(InputSource source);
private static Object[] findRootNode(Node root, boolean xmpmetaRequired, Object[] result);
private static DocumentBuilderFactory createDocumentBuilderFactory();
private static final String XMP_WITH_XXE;
}
class XMPMetaParserTest {
private static final String XMP_WITH_XXE;
@Test
public void xxeTestFromInputStream() throws IOException {
|
InputStream inputStream = null;
try {
inputStream = new ByteArrayInputStream(XMP_WITH_XXE.getBytes());
XMPMetaParser.parse(inputStream, null);
} catch (XMPException e) {
Assert.assertEquals("Children of resource property element must be XML elements", e.getMessage());
} finally {
if (inputStream != null) {
inputStream.close();
}
}
}
}
|
14892248_3
|
class XmpWriter {
public void close() throws IOException {
if (outputStream == null)
return;
try {
XMPMetaFactory.serialize(xmpMeta, outputStream, serializeOptions);
outputStream = null;
} catch (XMPException xmpExc) {
throw new IOException(xmpExc.getMessage());
}
}
public XmpWriter(OutputStream os, String utfEncoding, int extraSpace);
public XmpWriter(OutputStream os);
public XmpWriter(OutputStream os, PdfDictionary info);
public XmpWriter(OutputStream os, Map<String, String> info);
public XMPMeta getXmpMeta();
public void setReadOnly();
public void setAbout(String about);
@Deprecated public void addRdfDescription(String xmlns, String content);
@Deprecated public void addRdfDescription(XmpSchema s);
public void setProperty(String schemaNS, String propName, Object value);
public void appendArrayItem(String schemaNS, String arrayName, String value);
public void appendOrderedArrayItem(String schemaNS, String arrayName, String value);
public void appendAlternateArrayItem(String schemaNS, String arrayName, String value);
public void serialize(OutputStream externalOutputStream);
public void addDocInfoProperty(Object key, String value);
public static final String OUT_FOLDER;
public static final String CMP_FOLDER;
}
class XmpWriterTest {
public static final String OUT_FOLDER;
public static final String CMP_FOLDER;
@Test
public void createPdfAutomaticTest() throws IOException, DocumentException {
|
String fileName = "xmp_metadata_automatic.pdf";
// step 1
Document document = new Document();
// step 2
PdfWriter writer = PdfWriter.getInstance(document, new FileOutputStream(OUT_FOLDER + fileName));
document.addTitle("Hello World example");
document.addSubject("This example shows how to add metadata & XMP");
document.addKeywords("Metadata, iText, step 3");
document.addCreator("My program using 'iText'");
document.addAuthor("Bruno Lowagie & Paulo Soares");
writer.createXmpMetadata();
// step 3
document.open();
// step 4
document.add(new Paragraph("Hello World"));
// step 5
document.close();
CompareTool ct = new CompareTool();
Assert.assertNull(ct.compareXmp(OUT_FOLDER + fileName, CMP_FOLDER + fileName, true));
}
}
|
14892248_4
|
class XmpWriter {
public void close() throws IOException {
if (outputStream == null)
return;
try {
XMPMetaFactory.serialize(xmpMeta, outputStream, serializeOptions);
outputStream = null;
} catch (XMPException xmpExc) {
throw new IOException(xmpExc.getMessage());
}
}
public XmpWriter(OutputStream os, String utfEncoding, int extraSpace);
public XmpWriter(OutputStream os);
public XmpWriter(OutputStream os, PdfDictionary info);
public XmpWriter(OutputStream os, Map<String, String> info);
public XMPMeta getXmpMeta();
public void setReadOnly();
public void setAbout(String about);
@Deprecated public void addRdfDescription(String xmlns, String content);
@Deprecated public void addRdfDescription(XmpSchema s);
public void setProperty(String schemaNS, String propName, Object value);
public void appendArrayItem(String schemaNS, String arrayName, String value);
public void appendOrderedArrayItem(String schemaNS, String arrayName, String value);
public void appendAlternateArrayItem(String schemaNS, String arrayName, String value);
public void serialize(OutputStream externalOutputStream);
public void addDocInfoProperty(Object key, String value);
public static final String OUT_FOLDER;
public static final String CMP_FOLDER;
}
class XmpWriterTest {
public static final String OUT_FOLDER;
public static final String CMP_FOLDER;
@Test
public void manipulatePdfTest() throws IOException, DocumentException {
|
String fileName = "xmp_metadata_added.pdf";
PdfReader reader = new PdfReader(CMP_FOLDER + "pdf_metadata.pdf");
PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(OUT_FOLDER + fileName));
HashMap<String, String> info = reader.getInfo();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
XmpWriter xmp = new XmpWriter(baos, info);
xmp.close();
stamper.setXmpMetadata(baos.toByteArray());
stamper.close();
reader.close();
CompareTool ct = new CompareTool();
Assert.assertNull(ct.compareXmp(OUT_FOLDER + fileName, CMP_FOLDER + fileName, true));
}
}
|
14892248_5
|
class SimpleXMLParser {
public static void parse(final SimpleXMLDocHandler doc, final SimpleXMLDocHandlerComment comment, final Reader r, final boolean html) throws IOException {
SimpleXMLParser parser = new SimpleXMLParser(doc, comment, html);
parser.go(r);
}
private SimpleXMLParser(final SimpleXMLDocHandler doc, final SimpleXMLDocHandlerComment comment, final boolean html);
private void go(final Reader r);
private int restoreState();
private void saveState(final int s);
private void flush();
private void initTag();
private void doTag();
private void processTag(final boolean start);
private void throwException(final String s);
public static void parse(final SimpleXMLDocHandler doc, final InputStream in);
private static String getDeclaredEncoding(final String decl);
public static void parse(final SimpleXMLDocHandler doc,final Reader r);
@Deprecated public static String escapeXML(final String s, final boolean onlyASCII);
}
class SimpleXMLParserTest {
@Test
public void whitespaceHtml() throws IOException {
|
String whitespace = "<p>sometext\r moretext</p>";
String expected = "sometext moretext";
final StringBuilder b = new StringBuilder();
SimpleXMLParser.parse(new SimpleXMLDocHandler() {
public void text(final String str) {
b.append(str);
}
public void startElement(final String tag, final Map<String, String> h) {
}
public void startDocument() {
}
public void endElement(final String tag) {
}
public void endDocument() {
}
}, null, new StringReader(whitespace), true);
Assert.assertEquals(expected, b.toString());
}
}
|
14892248_6
|
class ArrayRandomAccessSource implements RandomAccessSource {
public int get(long offset) {
if (offset >= array.length) return -1;
return 0xff & array[(int)offset];
}
public ArrayRandomAccessSource(byte[] array);
public int get(long offset, byte[] bytes, int off, int len);
public long length();
public void close();
byte[] data;
}
class ArrayRandomAccessSourceTest {
byte[] data;
@Test
public void testGet() throws Exception {
|
ArrayRandomAccessSource s = new ArrayRandomAccessSource(data);
try{
for(int i = 0; i < data.length; i++){
int ch = s.get(i);
Assert.assertFalse(ch == -1);
Assert.assertEquals("Position " + i, data[i], (byte)ch);
}
Assert.assertEquals(-1, s.get(data.length));
} finally {
s.close();
}
}
}
|
14892248_7
|
class PagedChannelRandomAccessSource extends GroupedRandomAccessSource implements RandomAccessSource {
@Override
/**
* {@inheritDoc}
* Cleans the mapped bytebuffers and closes the channel
*/
public void close() throws IOException {
super.close();
channel.close();
}
public PagedChannelRandomAccessSource(FileChannel channel);
public PagedChannelRandomAccessSource(final FileChannel channel, final int totalBufferSize, final int maxOpenBuffers);
private static RandomAccessSource[] buildSources(final FileChannel channel, final int bufferSize);
@Override /** * {@inheritDoc} */ protected int getStartingSourceIndex(long offset);
@Override /** * {@inheritDoc} * For now, close the source that is no longer being used. In the future, we may implement an MRU that allows multiple pages to be opened at a time */ protected void sourceReleased(RandomAccessSource source);
@Override /** * {@inheritDoc} * Ensure that the source is mapped. In the future, we may implement an MRU that allows multiple pages to be opened at a time */ protected void sourceInUse(RandomAccessSource source);
byte[] data;
File f;
FileChannel channel;
}
class PagedChannelRandomAccessSourceTest {
byte[] data;
File f;
FileChannel channel;
@Test
public void testGet() throws Exception {
|
PagedChannelRandomAccessSource s = new PagedChannelRandomAccessSource(channel);
try{
for(int i = 0; i < data.length; i++){
int ch = s.get(i);
Assert.assertFalse("EOF hit unexpectedly at " + i + " out of " + data.length, ch == -1);
Assert.assertEquals("Position " + i, data[i], (byte)ch);
}
Assert.assertEquals(-1, s.get(data.length));
} finally {
s.close();
}
}
}
|
14892248_8
|
class PagedChannelRandomAccessSource extends GroupedRandomAccessSource implements RandomAccessSource {
@Override
/**
* {@inheritDoc}
* Cleans the mapped bytebuffers and closes the channel
*/
public void close() throws IOException {
super.close();
channel.close();
}
public PagedChannelRandomAccessSource(FileChannel channel);
public PagedChannelRandomAccessSource(final FileChannel channel, final int totalBufferSize, final int maxOpenBuffers);
private static RandomAccessSource[] buildSources(final FileChannel channel, final int bufferSize);
@Override /** * {@inheritDoc} */ protected int getStartingSourceIndex(long offset);
@Override /** * {@inheritDoc} * For now, close the source that is no longer being used. In the future, we may implement an MRU that allows multiple pages to be opened at a time */ protected void sourceReleased(RandomAccessSource source);
@Override /** * {@inheritDoc} * Ensure that the source is mapped. In the future, we may implement an MRU that allows multiple pages to be opened at a time */ protected void sourceInUse(RandomAccessSource source);
byte[] data;
File f;
FileChannel channel;
}
class PagedChannelRandomAccessSourceTest {
byte[] data;
File f;
FileChannel channel;
@Test
public void testGetArray() throws Exception {
|
byte[] chunk = new byte[257];
PagedChannelRandomAccessSource s = new PagedChannelRandomAccessSource(channel, data.length/10, 1);
try{
int pos = 0;
int count = s.get(pos, chunk, 0, chunk.length-1);
while (count != -1){
assertArrayEqual(data, pos, chunk, 0, count);
pos += count;
count = s.get(pos, chunk, 0, chunk.length-1);
}
Assert.assertEquals(-1, s.get(pos, chunk, 0, chunk.length));
} finally {
s.close();
}
}
}
|
14892248_9
|
class PagedChannelRandomAccessSource extends GroupedRandomAccessSource implements RandomAccessSource {
@Override
/**
* {@inheritDoc}
* Cleans the mapped bytebuffers and closes the channel
*/
public void close() throws IOException {
super.close();
channel.close();
}
public PagedChannelRandomAccessSource(FileChannel channel);
public PagedChannelRandomAccessSource(final FileChannel channel, final int totalBufferSize, final int maxOpenBuffers);
private static RandomAccessSource[] buildSources(final FileChannel channel, final int bufferSize);
@Override /** * {@inheritDoc} */ protected int getStartingSourceIndex(long offset);
@Override /** * {@inheritDoc} * For now, close the source that is no longer being used. In the future, we may implement an MRU that allows multiple pages to be opened at a time */ protected void sourceReleased(RandomAccessSource source);
@Override /** * {@inheritDoc} * Ensure that the source is mapped. In the future, we may implement an MRU that allows multiple pages to be opened at a time */ protected void sourceInUse(RandomAccessSource source);
byte[] data;
File f;
FileChannel channel;
}
class PagedChannelRandomAccessSourceTest {
byte[] data;
File f;
FileChannel channel;
@Test
public void testGetArrayMultiPages() throws Exception {
|
byte[] chunk = new byte[257];
PagedChannelRandomAccessSource s = new PagedChannelRandomAccessSource(channel, data.length/10, 7);
try{
int pos = 0;
int count = s.get(pos, chunk, 0, chunk.length-1);
while (count != -1){
assertArrayEqual(data, pos, chunk, 0, count);
pos += count;
count = s.get(pos, chunk, 0, chunk.length-1);
}
Assert.assertEquals(-1, s.get(pos, chunk, 0, chunk.length));
} finally {
s.close();
}
}
}
|
14960307_5
|
class NumberRadixUtil {
static public String normalizeLeadingHexZeroes(String v, int length) throws ConversionException {
if (v == null || v.length() == 0) {
throw new ConversionException("Empty or null value detected; unable to convert");
} else if (v.length() == length) {
return v;
} else if (v.length() < length) {
// add leading zeroes
int prepend = (length - v.length());
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < prepend; i++) {
sb.append('0');
}
sb.append(v);
return sb.toString();
} else {
// remove leading zeroes (or error out if not zeroes)
int remove = (v.length() - length);
// check if any of these are non-zero
for (int i = 0; i < remove; i++) {
if (v.charAt(i) != '0') {
throw new ConversionOverflowException("Overflow of value detected; unable to trim value [" + v + "] to length " + length);
}
}
return v.substring(remove);
}
}
static public NumberRadixResult parseNumberRadix(String number);
}
class NumberRadixUtilTest {
@Test
public void normalizeLeadingHexZeroes() throws Exception {
|
// appending digits or equal
Assert.assertEquals("00", NumberRadixUtil.normalizeLeadingHexZeroes("0", 2));
Assert.assertEquals("00", NumberRadixUtil.normalizeLeadingHexZeroes("00", 2));
Assert.assertEquals("0F", NumberRadixUtil.normalizeLeadingHexZeroes("F", 2));
Assert.assertEquals("FF", NumberRadixUtil.normalizeLeadingHexZeroes("FF", 2));
Assert.assertEquals("0000", NumberRadixUtil.normalizeLeadingHexZeroes("0", 4));
Assert.assertEquals("0000", NumberRadixUtil.normalizeLeadingHexZeroes("00", 4));
Assert.assertEquals("000F", NumberRadixUtil.normalizeLeadingHexZeroes("F", 4));
Assert.assertEquals("00FF", NumberRadixUtil.normalizeLeadingHexZeroes("FF", 4));
Assert.assertEquals("0FFF", NumberRadixUtil.normalizeLeadingHexZeroes("FFF", 4));
Assert.assertEquals("FFFF", NumberRadixUtil.normalizeLeadingHexZeroes("FFFF", 4));
Assert.assertEquals("00000000", NumberRadixUtil.normalizeLeadingHexZeroes("0", 8));
Assert.assertEquals("00000000", NumberRadixUtil.normalizeLeadingHexZeroes("00", 8));
Assert.assertEquals("0000000F", NumberRadixUtil.normalizeLeadingHexZeroes("F", 8));
Assert.assertEquals("000000FF", NumberRadixUtil.normalizeLeadingHexZeroes("FF", 8));
Assert.assertEquals("00000FFF", NumberRadixUtil.normalizeLeadingHexZeroes("FFF", 8));
Assert.assertEquals("0000FFFF", NumberRadixUtil.normalizeLeadingHexZeroes("FFFF", 8));
Assert.assertEquals("FFFFFFFF", NumberRadixUtil.normalizeLeadingHexZeroes("FFFFFFFF", 8));
// trimming digits
Assert.assertEquals("00", NumberRadixUtil.normalizeLeadingHexZeroes("000", 2));
Assert.assertEquals("00", NumberRadixUtil.normalizeLeadingHexZeroes("0000", 2));
Assert.assertEquals("0F", NumberRadixUtil.normalizeLeadingHexZeroes("00F", 2));
Assert.assertEquals("FF", NumberRadixUtil.normalizeLeadingHexZeroes("000000000FF", 2));
}
}
|
17537835_0
|
class ServiceInvocationHandler implements InvocationHandler {
@Override
public Object invoke(Object proxy, final Method m, Object[] params) throws Throwable {
if (OBJECT_METHODS.contains(m)) {
if (m.getName().equals("equals")) {
params = new Object[] {Proxy.getInvocationHandler(params[0])};
}
return m.invoke(this, params);
}
ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
final Object[] paramsFinal = params;
return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
return m.invoke(serviceObject, paramsFinal);
}
});
} catch (Throwable ex) {
Throwable theCause = ex.getCause() == null ? ex : ex.getCause();
throw exceptionMapper.mapException(m, theCause);
} finally {
Thread.currentThread().setContextClassLoader(oldCl);
}
}
ServiceInvocationHandler(Object serviceObject, Class<?> iType);
private static final Map<String, Method> OBJECT_METHODS;
}
class ServiceInvocationHandlerTest {
private static final Map<String, Method> OBJECT_METHODS;
@Test
public void testInvoke() throws Throwable {
|
ServiceInvocationHandler sih = new ServiceInvocationHandler("hello", String.class);
Method m = String.class.getMethod("length");
assertEquals(5, sih.invoke(null, m, new Object[] {}));
}
}
|
17537835_1
|
class ServiceInvocationHandler implements InvocationHandler {
@Override
public Object invoke(Object proxy, final Method m, Object[] params) throws Throwable {
if (OBJECT_METHODS.contains(m)) {
if (m.getName().equals("equals")) {
params = new Object[] {Proxy.getInvocationHandler(params[0])};
}
return m.invoke(this, params);
}
ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
final Object[] paramsFinal = params;
return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
return m.invoke(serviceObject, paramsFinal);
}
});
} catch (Throwable ex) {
Throwable theCause = ex.getCause() == null ? ex : ex.getCause();
throw exceptionMapper.mapException(m, theCause);
} finally {
Thread.currentThread().setContextClassLoader(oldCl);
}
}
ServiceInvocationHandler(Object serviceObject, Class<?> iType);
private static final Map<String, Method> OBJECT_METHODS;
}
class ServiceInvocationHandlerTest {
private static final Map<String, Method> OBJECT_METHODS;
@Test
public void testInvokeObjectMethod() throws Throwable {
|
final List<String> called = new ArrayList<>();
ServiceInvocationHandler sih = new ServiceInvocationHandler("hi", String.class) {
@Override
public boolean equals(Object obj) {
called.add("equals");
return super.equals(obj);
}
@Override
public int hashCode() {
called.add("hashCode");
return super.hashCode();
}
@Override
public String toString() {
called.add("toString");
return "somestring";
}
};
Object proxy = Proxy.newProxyInstance(
getClass().getClassLoader(), new Class[] {Runnable.class}, sih);
assertEquals(true,
sih.invoke(null, OBJECT_METHODS.get("equals"), new Object[] {proxy}));
assertEquals(System.identityHashCode(sih),
sih.invoke(null, OBJECT_METHODS.get("hashCode"), new Object[] {}));
assertEquals("somestring",
sih.invoke(null, OBJECT_METHODS.get("toString"), new Object[] {}));
assertEquals(Arrays.asList("equals", "hashCode", "toString"), called);
}
}
|
17537835_2
|
class PropertyHelper {
@SuppressWarnings("unchecked")
public static Collection<String> getMultiValueProperty(Object property) {
if (property == null) {
return Collections.emptyList();
} else if (property instanceof Collection) {
return (Collection<String>)property;
} else if (property instanceof String[]) {
return Arrays.asList((String[])property);
} else {
return Collections.singleton(property.toString());
}
}
private PropertyHelper();
public static String getProperty(Map<String, Object> dict, String name);
public static String getFirstNonEmptyStringProperty(Map<String, Object> dict, String... keys);
}
class PropertyHelperTest {
@Test
public void testMultiValuePropertyAsString() {
|
assertEquals(Collections.singleton("hi"),
PropertyHelper.getMultiValueProperty("hi"));
}
}
|
17537835_3
|
class PropertyHelper {
@SuppressWarnings("unchecked")
public static Collection<String> getMultiValueProperty(Object property) {
if (property == null) {
return Collections.emptyList();
} else if (property instanceof Collection) {
return (Collection<String>)property;
} else if (property instanceof String[]) {
return Arrays.asList((String[])property);
} else {
return Collections.singleton(property.toString());
}
}
private PropertyHelper();
public static String getProperty(Map<String, Object> dict, String name);
public static String getFirstNonEmptyStringProperty(Map<String, Object> dict, String... keys);
}
class PropertyHelperTest {
@Test
public void testMultiValuePropertyAsArray() {
|
assertEquals(Arrays.asList("a", "b"),
PropertyHelper.getMultiValueProperty(new String[]{"a", "b"}));
}
}
|
17537835_4
|
class PropertyHelper {
@SuppressWarnings("unchecked")
public static Collection<String> getMultiValueProperty(Object property) {
if (property == null) {
return Collections.emptyList();
} else if (property instanceof Collection) {
return (Collection<String>)property;
} else if (property instanceof String[]) {
return Arrays.asList((String[])property);
} else {
return Collections.singleton(property.toString());
}
}
private PropertyHelper();
public static String getProperty(Map<String, Object> dict, String name);
public static String getFirstNonEmptyStringProperty(Map<String, Object> dict, String... keys);
}
class PropertyHelperTest {
@Test
public void testMultiValuePropertyAsCollection() {
|
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
assertEquals(list, PropertyHelper.getMultiValueProperty(list));
}
}
|
17537835_5
|
class PropertyHelper {
@SuppressWarnings("unchecked")
public static Collection<String> getMultiValueProperty(Object property) {
if (property == null) {
return Collections.emptyList();
} else if (property instanceof Collection) {
return (Collection<String>)property;
} else if (property instanceof String[]) {
return Arrays.asList((String[])property);
} else {
return Collections.singleton(property.toString());
}
}
private PropertyHelper();
public static String getProperty(Map<String, Object> dict, String name);
public static String getFirstNonEmptyStringProperty(Map<String, Object> dict, String... keys);
}
class PropertyHelperTest {
@Test
public void testMultiValuePropertyNull() {
|
assertTrue(PropertyHelper.getMultiValueProperty(null).isEmpty());
}
}
|
17537835_7
|
class IntentManagerImpl implements IntentManager {
@Override
public List<Object> getIntentsFromService(Object serviceBean) {
List<Object> intents = new ArrayList<>();
if (serviceBean instanceof IntentsProvider) {
intents.addAll(((IntentsProvider)serviceBean).getIntents());
}
Features features = serviceBean.getClass().getAnnotation(Features.class);
if (features != null && features.classes() != null) {
for (Class<?> clazz : features.classes()) {
try {
intents.add(clazz.newInstance());
} catch (Exception e) {
throw new RuntimeException("Could not instantiate feature from class " + clazz.getName(), e);
}
}
}
return intents;
}
@Activate public void activate(BundleContext context);
@Deactivate public void deactivate();
public synchronized void addIntent(Object intent, String intentName);
public synchronized void removeIntent(Object intent, String intentName);
@Override @SuppressWarnings("unchecked") public synchronized List<Object> getRequiredIntents(Set<String> requiredIntents);
@Override public T getIntent(Class<? extends T> type, List<Object> intents);
@Override public List<T> getIntents(Class<? extends T> type, List<Object> intents);
public synchronized String[] assertAllIntentsSupported(Set<String> requiredIntents);
private synchronized Set<String> getMissingIntents(Collection<String> requiredIntents);
@Override public Set<String> getExported(Map<String, Object> sd);
@Override public Set<String> getImported(Map<String, Object> sd);
private static Collection<String> parseIntents(Collection<String> intents);
}
class IntentManagerImplTest {
@Test
public void testIntentsFromFeatureAnn() {
|
IntentManagerImpl im = new IntentManagerImpl();
List<Object> intents = im.getIntentsFromService(new DummyServiceWithLogging());
Assert.assertEquals(1, intents.size());
Object feature = intents.iterator().next();
Assert.assertEquals(GZIPFeature.class, feature.getClass());
}
}
|
17537835_8
|
class IntentManagerImpl implements IntentManager {
@Override
public List<Object> getIntentsFromService(Object serviceBean) {
List<Object> intents = new ArrayList<>();
if (serviceBean instanceof IntentsProvider) {
intents.addAll(((IntentsProvider)serviceBean).getIntents());
}
Features features = serviceBean.getClass().getAnnotation(Features.class);
if (features != null && features.classes() != null) {
for (Class<?> clazz : features.classes()) {
try {
intents.add(clazz.newInstance());
} catch (Exception e) {
throw new RuntimeException("Could not instantiate feature from class " + clazz.getName(), e);
}
}
}
return intents;
}
@Activate public void activate(BundleContext context);
@Deactivate public void deactivate();
public synchronized void addIntent(Object intent, String intentName);
public synchronized void removeIntent(Object intent, String intentName);
@Override @SuppressWarnings("unchecked") public synchronized List<Object> getRequiredIntents(Set<String> requiredIntents);
@Override public T getIntent(Class<? extends T> type, List<Object> intents);
@Override public List<T> getIntents(Class<? extends T> type, List<Object> intents);
public synchronized String[] assertAllIntentsSupported(Set<String> requiredIntents);
private synchronized Set<String> getMissingIntents(Collection<String> requiredIntents);
@Override public Set<String> getExported(Map<String, Object> sd);
@Override public Set<String> getImported(Map<String, Object> sd);
private static Collection<String> parseIntents(Collection<String> intents);
}
class IntentManagerImplTest {
@Test
public void testIntentsFromIntentsProvider() {
|
IntentManagerImpl im = new IntentManagerImpl();
List<Object> intents = im.getIntentsFromService(new DummyServiceWithLoggingIP());
Assert.assertEquals(1, intents.size());
Object feature = intents.iterator().next();
Assert.assertEquals(GZIPFeature.class, feature.getClass());
}
}
|
17537835_9
|
class HttpServiceManager {
public String getAbsoluteAddress(String contextRoot, String endpointAddress) {
if (endpointAddress.startsWith("http")) {
return endpointAddress;
}
String effContextRoot = contextRoot == null ? cxfServletAlias : contextRoot;
return this.httpBase + effContextRoot + endpointAddress;
}
@Activate public void activate(ComponentContext compContext);
public void initFromConfig(Dictionary<String, Object> config);
private String getWithDefault(Object value, String defaultValue);
public Bus registerServlet(Bus bus, String contextRoot, BundleContext callingContext, Long sid);
private void registerUnexportHook(Long sid, String alias);
public String getDefaultAddress(Class<?> type);
public void setContext(BundleContext context);
@Reference public void setHttpService(HttpService httpService);
}
class HttpServiceManagerTest {
@Test
public void testGetAbsoluteAddress() {
|
HttpServiceManager manager = new HttpServiceManager();
manager.initFromConfig(null);
String address1 = manager.getAbsoluteAddress(null, "/myservice");
assertEquals("http://localhost:8181/cxf/myservice", address1);
String address2 = manager.getAbsoluteAddress("/mycontext", "/myservice");
assertEquals("http://localhost:8181/mycontext/myservice", address2);
}
}
|
18203743_0
|
class JMSAppender implements PaxAppender {
public void doAppend(final PaxLoggingEvent paxLoggingEvent) {
if (exclude(paxLoggingEvent) || jmsConnectionFactory == null) {
return;
}
Runnable worker = new Runnable() {
public void run() {
try {
// Send message to the destination
TextMessage message = getOrCreateSession().createTextMessage();
message.setText(format.toString(paxLoggingEvent));
MessageProducer producer = getOrCreatePublisher();
producer.send(message);
} catch (JMSException e) {
LOG.warn("Exception caught while sending log event - reinitializing JMS resources to recover",e);
closeJMSResources();
}
}
};
executor.execute(worker);
}
public void close();
public void onBind(ConnectionFactory service);
public void onUnbind(ConnectionFactory service);
private static boolean exclude(PaxLoggingEvent event);
private static boolean startsWith(String string, String start);
public void setJmsConnectionFactory(ConnectionFactory jmsConnectionFactory);
public void setDestinationName(String destinationName);
public void setFormat(String name);
protected Connection getOrCreateConnection();
protected Session getOrCreateSession();
protected MessageProducer getOrCreatePublisher();
private void closeJMSResources();
private static void close(Object obj);
private static final String EVENTS_TOPIC;
private JMSAppender appender;
private static BrokerService broker;
}
class JMSAppenderTest {
private static final String EVENTS_TOPIC;
private JMSAppender appender;
private static BrokerService broker;
@Test
public void testLogstashAppender() throws InterruptedException {
|
MockEndpoint events = getMockEndpoint("mock:events");
events.expectedMessageCount(1);
appender.doAppend(MockEvents.createInfoEvent());
assertMockEndpointsSatisfied();
}
}
|
18203743_1
|
class LogstashEventFormat implements LoggingEventFormat {
public String toString(PaxLoggingEvent event) {
JsonObjectBuilder object = Json.createObjectBuilder();
try {
object.add(MESSAGE, event.getMessage());
object.add(SOURCE, event.getLoggerName());
object.add(TIMESTAMP, TIMESTAMP_FORMAT.format(new Date(event.getTimeStamp())));
JsonObjectBuilder fields = Json.createObjectBuilder();
for (Object property : event.getProperties().entrySet()) {
Map.Entry<String, Object> entry = (Map.Entry<String, Object>) property;
fields.add(entry.getKey(), entry.getValue().toString());
}
object.add(FIELDS, fields);
JsonArrayBuilder tags = Json.createArrayBuilder();
tags.add(event.getLevel().toString());
object.add(TAGS, tags);
} catch (JsonException e) {
// let's return a minimal, String-based message representation instead
return "{ \"" + MESSAGE + "\" : " + event.getMessage() + "}";
}
return object.build().toString();
}
private final LoggingEventFormat format;
}
class LogstashEventFormatTest {
private final LoggingEventFormat format;
@Test
public void testBasicLogstashFormat() throws JsonException {
|
PaxLoggingEvent event = MockEvents.createInfoEvent();
JsonObject object = Json.createReader(new StringReader(format.toString(event))).readObject();
assertEquals(MockEvents.LOG_MESSAGE, object.getString(LogstashEventFormat.MESSAGE));
assertEquals(MockEvents.LOGGER_NAME, object.getString(LogstashEventFormat.SOURCE));
assertEquals("INFO", object.getJsonArray(LogstashEventFormat.TAGS).getString(0));
assertEquals(MockEvents.LOG_PROPERTY_VALUE,
object.getJsonObject(LogstashEventFormat.FIELDS).getString(MockEvents.LOG_PROPERTY_ID));
assertNotNull(object.get(LogstashEventFormat.TIMESTAMP));
System.out.println(object);
}
}
|
18242149_0
|
class AsmApi {
static int value() {
return Opcodes.ASM7;
}
private AsmApi();
}
class AsmApiTest {
@Test
public void testValue() {
|
assertEquals(Opcodes.ASM7, AsmApi.value());
}
}
|
18467626_0
|
class CommandApdu {
public byte[] toBytes() {
int length = 4; // CLA, INS, P1, P2
if (mData != null && mData.length != 0) {
length += 1; // LC
length += mData.length; // DATA
}
if (mLeUsed) {
length += 1; // LE
}
byte[] apdu = new byte[length];
int index = 0;
apdu[index] = (byte) mCla;
index++;
apdu[index] = (byte) mIns;
index++;
apdu[index] = (byte) mP1;
index++;
apdu[index] = (byte) mP2;
index++;
if (mData != null && mData.length != 0) {
apdu[index] = (byte) mLc;
index++;
System.arraycopy(mData, 0, apdu, index, mData.length);
index += mData.length;
}
if (mLeUsed) {
apdu[index] += (byte) mLe; // LE
}
return apdu;
}
public CommandApdu(final CommandEnum pEnum, final byte[] data, final int le);
public CommandApdu(final CommandEnum pEnum, final int p1, final int p2, final int le);
public CommandApdu(final CommandEnum pEnum, final int p1, final int p2);
public CommandApdu(final CommandEnum pEnum, final int p1, final int p2, final byte[] data, final int le);
}
class CommandApduTest {
@Test
public void testToByte() {
|
Assertions.assertThat(BytesUtils.bytesToString(new CommandApdu(CommandEnum.GPO, 0x01, 0x02, 0x01).toBytes())).isEqualTo(
"80 A8 01 02 01");
Assertions.assertThat(BytesUtils.bytesToString(new CommandApdu(CommandEnum.GPO, new byte[] {}, 0x01).toBytes()))
.isEqualTo("80 A8 00 00 01");
Assertions.assertThat(BytesUtils.bytesToString(new CommandApdu(CommandEnum.GPO, null, 0x01).toBytes())).isEqualTo(
"80 A8 00 00 01");
Assertions.assertThat(BytesUtils.bytesToString(new CommandApdu(CommandEnum.GPO, 0x01, 0x02).toBytes())).isEqualTo(
"80 A8 01 02");
}
}
|
18467626_1
|
class ResponseUtils {
public static boolean isSucceed(final byte[] pByte) {
return contains(pByte, SwEnum.SW_9000);
}
private ResponseUtils();
public static boolean isEquals(final byte[] pByte, final SwEnum pEnum);
public static boolean contains(final byte[] pByte, final SwEnum... pEnum);
}
class ResponseUtilsTest {
@Test
public void testResponseIsSucceed() {
|
Assertions.assertThat(ResponseUtils.isSucceed(new byte[] { (byte) 0x90, 0 })).isEqualTo(true);
Assertions.assertThat(ResponseUtils.isSucceed(new byte[] { 0, (byte) 0x90, 0 })).isEqualTo(true);
Assertions.assertThat(ResponseUtils.isSucceed(new byte[] { (byte) 0x00, 0 })).isEqualTo(false);
Assertions.assertThat(ResponseUtils.isSucceed(null)).isEqualTo(false);
}
}
|
18467626_2
|
class ResponseUtils {
public static boolean isEquals(final byte[] pByte, final SwEnum pEnum) {
return contains(pByte, pEnum);
}
private ResponseUtils();
public static boolean isSucceed(final byte[] pByte);
public static boolean contains(final byte[] pByte, final SwEnum... pEnum);
}
class ResponseUtilsTest {
@Test
public void testResponseIsEquals() {
|
Assertions.assertThat(ResponseUtils.isEquals(new byte[] { (byte) 0x90, 0 }, SwEnum.SW_9000)).isEqualTo(true);
Assertions.assertThat(ResponseUtils.isEquals(new byte[] { (byte) 0x6D, 18 }, SwEnum.SW_6D)).isEqualTo(true);
Assertions.assertThat(ResponseUtils.isEquals(new byte[] { (byte) 0x00, 0 }, SwEnum.SW_6D)).isEqualTo(false);
Assertions.assertThat(ResponseUtils.isEquals(null, SwEnum.SW_6D)).isEqualTo(false);
}
}
|
18467626_4
|
class TlvUtil {
public static String prettyPrintAPDUResponse(final byte[] data) {
return prettyPrintAPDUResponse(data, 0);
}
private TlvUtil();
private static ITag searchTagById(final int tagId);
public static String getFormattedTagAndLength(final byte[] data, final int indentLength);
public static TLV getNextTLV(final TLVInputStream stream);
private static String getTagValueAsString(final ITag tag, final byte[] value);
public static List<TagAndLength> parseTagAndLength(final byte[] data);
public static List<TLV> getlistTLV(final byte[] pData, final ITag pTag, final boolean pAdd);
public static List<TLV> getlistTLV(final byte[] pData, final ITag... pTag);
public static byte[] getValue(final byte[] pData, final ITag... pTag);
public static String prettyPrintAPDUResponse(final byte[] data, final int indentLength);
public static String getSpaces(final int length);
public static String prettyPrintHex(final String in, final int indent);
public static String prettyPrintHex(final byte[] data);
public static String prettyPrintHex(final String in, final int indent, final boolean wrapLines);
public static String getSafePrintChars(final byte[] byteArray);
public static String getSafePrintChars(final byte[] byteArray, final int startPos, final int length);
public static int getLength(final List<TagAndLength> pList);
private static final byte[] DATA;
}
class TlvUtilTest {
private static final byte[] DATA;
@Test
public void testPrettyPrint() {
|
String expResult = "\n"//
+ "70 63 -- Record Template (EMV Proprietary)\n" //
+ " 61 13 -- Application Template\n" //
+ " 4F 09 -- Application Identifier (AID) - card\n" //
+ " A0 00 00 03 15 10 10 05 28 (BINARY)\n" //
+ " 50 03 -- Application Label\n" //
+ " 50 49 4E (=PIN)\n" //
+ " 87 01 -- Application Priority Indicator\n"//
+ " 01 (BINARY)\n" //
+ " 61 15 -- Application Template\n"//
+ " 4F 07 -- Application Identifier (AID) - card\n"//
+ " A0 00 00 00 04 30 60 (BINARY)\n" //
+ " 50 07 -- Application Label\n"//
+ " 4D 41 45 53 54 52 4F (=MAESTRO)\n" //
+ " 87 01 -- Application Priority Indicator\n"//
+ " 02 (BINARY)\n" //
+ " 61 1D -- Application Template\n"//
+ " 4F 07 -- Application Identifier (AID) - card\n"//
+ " A0 00 00 00 04 80 02 (BINARY)\n" //
+ " 50 0F -- Application Label\n"//
+ " 53 65 63 75 72 65 43 6F 64 65 20 41 75 74 68 (=SecureCode Auth)\n" //
+ " 87 01 -- Application Priority Indicator\n" //
+ " 00 (BINARY)\n"//
+ " 61 16 -- Application Template\n" //
+ " 4F 07 -- Application Identifier (AID) - card\n"//
+ " A0 00 00 03 15 60 20 (BINARY)\n" //
+ " 50 08 -- Application Label\n"//
+ " 43 68 69 70 6B 6E 69 70 (=Chipknip)\n"//
+ " 87 01 -- Application Priority Indicator\n" //
+ " 00 (BINARY)\n" //
+ "90 00 -- Command successfully executed (OK)";
Assertions.assertThat(TlvUtil.prettyPrintAPDUResponse(DATA)).isEqualTo(expResult);
}
}
|
18467626_5
|
class TlvUtil {
public static String prettyPrintAPDUResponse(final byte[] data) {
return prettyPrintAPDUResponse(data, 0);
}
private TlvUtil();
private static ITag searchTagById(final int tagId);
public static String getFormattedTagAndLength(final byte[] data, final int indentLength);
public static TLV getNextTLV(final TLVInputStream stream);
private static String getTagValueAsString(final ITag tag, final byte[] value);
public static List<TagAndLength> parseTagAndLength(final byte[] data);
public static List<TLV> getlistTLV(final byte[] pData, final ITag pTag, final boolean pAdd);
public static List<TLV> getlistTLV(final byte[] pData, final ITag... pTag);
public static byte[] getValue(final byte[] pData, final ITag... pTag);
public static String prettyPrintAPDUResponse(final byte[] data, final int indentLength);
public static String getSpaces(final int length);
public static String prettyPrintHex(final String in, final int indent);
public static String prettyPrintHex(final byte[] data);
public static String prettyPrintHex(final String in, final int indent, final boolean wrapLines);
public static String getSafePrintChars(final byte[] byteArray);
public static String getSafePrintChars(final byte[] byteArray, final int startPos, final int length);
public static int getLength(final List<TagAndLength> pList);
private static final byte[] DATA;
}
class TlvUtilTest {
private static final byte[] DATA;
@Test
public void testPrettyPrintTransactionRecord() {
|
// Assertions.assertThat(TlvUtil.prettyPrintAPDUResponse(BytesUtils.fromString(""))).isEqualTo("");
Assertions.assertThat(TlvUtil.prettyPrintAPDUResponse(BytesUtils.fromString("00 00 00 00 46 00 40 02 50 09 78 14 03 16 20 90 00")))
.isEqualTo("");
}
}
|
18467626_6
|
class TlvUtil {
private static ITag searchTagById(final int tagId) {
return EmvTags.getNotNull(TLVUtil.getTagAsBytes(tagId));
}
private TlvUtil();
public static String getFormattedTagAndLength(final byte[] data, final int indentLength);
public static TLV getNextTLV(final TLVInputStream stream);
private static String getTagValueAsString(final ITag tag, final byte[] value);
public static List<TagAndLength> parseTagAndLength(final byte[] data);
public static String prettyPrintAPDUResponse(final byte[] data);
public static List<TLV> getlistTLV(final byte[] pData, final ITag pTag, final boolean pAdd);
public static List<TLV> getlistTLV(final byte[] pData, final ITag... pTag);
public static byte[] getValue(final byte[] pData, final ITag... pTag);
public static String prettyPrintAPDUResponse(final byte[] data, final int indentLength);
public static String getSpaces(final int length);
public static String prettyPrintHex(final String in, final int indent);
public static String prettyPrintHex(final byte[] data);
public static String prettyPrintHex(final String in, final int indent, final boolean wrapLines);
public static String getSafePrintChars(final byte[] byteArray);
public static String getSafePrintChars(final byte[] byteArray, final int startPos, final int length);
public static int getLength(final List<TagAndLength> pList);
private static final byte[] DATA;
}
class TlvUtilTest {
private static final byte[] DATA;
@Test
public void testSearchTagById() throws Exception {
|
ITag tag = (ITag) ReflectionTestUtils.invokeMethod(TlvUtil.class, "searchTagById", 0x9F6B);
Assertions.assertThat(tag).isEqualTo(EmvTags.TRACK2_DATA);
tag = (ITag) ReflectionTestUtils.invokeMethod(TlvUtil.class, "searchTagById", 0xFFFF);
Assertions.assertThat(tag.getName()).isEqualTo("[UNKNOWN TAG]");
Assertions.assertThat(tag.getDescription()).isEqualTo("");
Assertions.assertThat(tag.getTagBytes()).isEqualTo(BytesUtils.fromString("FFFF"));
Assertions.assertThat(tag.getNumTagBytes()).isEqualTo(2);
Assertions.assertThat(tag.isConstructed()).isEqualTo(true);
Assertions.assertThat(tag.getTagValueType()).isEqualTo(TagValueTypeEnum.BINARY);
Assertions.assertThat(tag.getType()).isEqualTo(TagTypeEnum.CONSTRUCTED);
}
}
|
18467626_7
|
class TlvUtil {
public static String getFormattedTagAndLength(final byte[] data, final int indentLength) {
StringBuilder buf = new StringBuilder();
String indent = getSpaces(indentLength);
TLVInputStream stream = new TLVInputStream(new ByteArrayInputStream(data));
boolean firstLine = true;
try {
while (stream.available() > 0) {
if (firstLine) {
firstLine = false;
} else {
buf.append("\n");
}
buf.append(indent);
ITag tag = searchTagById(stream.readTag());
int length = stream.readLength();
buf.append(prettyPrintHex(tag.getTagBytes()));
buf.append(" ");
buf.append(String.format("%02x", length));
buf.append(" -- ");
buf.append(tag.getName());
}
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(stream);
}
return buf.toString();
}
private TlvUtil();
private static ITag searchTagById(final int tagId);
public static TLV getNextTLV(final TLVInputStream stream);
private static String getTagValueAsString(final ITag tag, final byte[] value);
public static List<TagAndLength> parseTagAndLength(final byte[] data);
public static String prettyPrintAPDUResponse(final byte[] data);
public static List<TLV> getlistTLV(final byte[] pData, final ITag pTag, final boolean pAdd);
public static List<TLV> getlistTLV(final byte[] pData, final ITag... pTag);
public static byte[] getValue(final byte[] pData, final ITag... pTag);
public static String prettyPrintAPDUResponse(final byte[] data, final int indentLength);
public static String getSpaces(final int length);
public static String prettyPrintHex(final String in, final int indent);
public static String prettyPrintHex(final byte[] data);
public static String prettyPrintHex(final String in, final int indent, final boolean wrapLines);
public static String getSafePrintChars(final byte[] byteArray);
public static String getSafePrintChars(final byte[] byteArray, final int startPos, final int length);
public static int getLength(final List<TagAndLength> pList);
private static final byte[] DATA;
}
class TlvUtilTest {
private static final byte[] DATA;
@Test
public void testGetFormattedTagAndLength() throws Exception {
|
byte[] data = BytesUtils.fromString("9f6b01");
Assertions.assertThat(TlvUtil.getFormattedTagAndLength(data, 1)).isEqualTo(" 9F 6B 01 -- Track 2 Data");
}
}
|
18467626_8
|
class TlvUtil {
public static List<TLV> getlistTLV(final byte[] pData, final ITag pTag, final boolean pAdd) {
List<TLV> list = new ArrayList<TLV>();
TLVInputStream stream = new TLVInputStream(new ByteArrayInputStream(pData));
try {
while (stream.available() > 0) {
TLV tlv = TlvUtil.getNextTLV(stream);
if (tlv == null) {
break;
}
if (pAdd) {
list.add(tlv);
} else if (tlv.getTag().isConstructed()) {
list.addAll(TlvUtil.getlistTLV(tlv.getValueBytes(), pTag, tlv.getTag() == pTag));
}
}
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(stream);
}
return list;
}
private TlvUtil();
private static ITag searchTagById(final int tagId);
public static String getFormattedTagAndLength(final byte[] data, final int indentLength);
public static TLV getNextTLV(final TLVInputStream stream);
private static String getTagValueAsString(final ITag tag, final byte[] value);
public static List<TagAndLength> parseTagAndLength(final byte[] data);
public static String prettyPrintAPDUResponse(final byte[] data);
public static List<TLV> getlistTLV(final byte[] pData, final ITag... pTag);
public static byte[] getValue(final byte[] pData, final ITag... pTag);
public static String prettyPrintAPDUResponse(final byte[] data, final int indentLength);
public static String getSpaces(final int length);
public static String prettyPrintHex(final String in, final int indent);
public static String prettyPrintHex(final byte[] data);
public static String prettyPrintHex(final String in, final int indent, final boolean wrapLines);
public static String getSafePrintChars(final byte[] byteArray);
public static String getSafePrintChars(final byte[] byteArray, final int startPos, final int length);
public static int getLength(final List<TagAndLength> pList);
private static final byte[] DATA;
}
class TlvUtilTest {
private static final byte[] DATA;
@Test
public void testListTLV() throws Exception {
|
Assertions.assertThat(TlvUtil.getlistTLV(DATA, EmvTags.APPLICATION_TEMPLATE, false).size()).isEqualTo(12);
Assertions.assertThat(TlvUtil.getlistTLV(DATA, EmvTags.RECORD_TEMPLATE, false).size()).isEqualTo(4);
Assertions.assertThat(TlvUtil.getlistTLV(DATA, EmvTags.TRANSACTION_CURRENCY_CODE, false).size()).isEqualTo(0);
}
}
|
18467626_9
|
class TlvUtil {
public static List<TagAndLength> parseTagAndLength(final byte[] data) {
List<TagAndLength> tagAndLengthList = new ArrayList<TagAndLength>();
if (data != null) {
TLVInputStream stream = new TLVInputStream(new ByteArrayInputStream(data));
try {
while (stream.available() > 0) {
if (stream.available() < 2) {
throw new TlvException("Data length < 2 : " + stream.available());
}
ITag tag = searchTagById(stream.readTag());
int tagValueLength = stream.readLength();
tagAndLengthList.add(new TagAndLength(tag, tagValueLength));
}
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(stream);
}
}
return tagAndLengthList;
}
private TlvUtil();
private static ITag searchTagById(final int tagId);
public static String getFormattedTagAndLength(final byte[] data, final int indentLength);
public static TLV getNextTLV(final TLVInputStream stream);
private static String getTagValueAsString(final ITag tag, final byte[] value);
public static String prettyPrintAPDUResponse(final byte[] data);
public static List<TLV> getlistTLV(final byte[] pData, final ITag pTag, final boolean pAdd);
public static List<TLV> getlistTLV(final byte[] pData, final ITag... pTag);
public static byte[] getValue(final byte[] pData, final ITag... pTag);
public static String prettyPrintAPDUResponse(final byte[] data, final int indentLength);
public static String getSpaces(final int length);
public static String prettyPrintHex(final String in, final int indent);
public static String prettyPrintHex(final byte[] data);
public static String prettyPrintHex(final String in, final int indent, final boolean wrapLines);
public static String getSafePrintChars(final byte[] byteArray);
public static String getSafePrintChars(final byte[] byteArray, final int startPos, final int length);
public static int getLength(final List<TagAndLength> pList);
private static final byte[] DATA;
}
class TlvUtilTest {
private static final byte[] DATA;
@Test
public void testParseTagAndLength() throws Exception {
|
Assertions.assertThat(TlvUtil.parseTagAndLength(null)).isEqualTo(new ArrayList<TagAndLength>());
}
}
|
20043683_0
|
class SnomedDescriptionComparator implements Comparator<SnomedConcept> {
public int compare(final SnomedConcept o1, final SnomedConcept o2) {
if (o1 == o2) return 0;
if (o1 != null) {
if (o2 == null) return 1;
else return o1.candidatePreferred.compareTo(o2.candidatePreferred);
}
return -1;
}
}
class SnomedDescriptionComparatorTest {
@Test
public void testCompare() throws Exception {
|
// sort just the descriptions to get the comparative order
final Collection<String> sortedDescriptionsColl = new TreeSet<>();
for (final SnomedConcept concept : TEST_DATA) {
sortedDescriptionsColl.add(concept.candidatePreferred);
}
final List<String> sortedDescriptions = new ArrayList<>(sortedDescriptionsColl);
// then use the comparator
final List<SnomedConcept> sorted = new ArrayList<>(TEST_DATA);
Collections.sort(sorted, new SnomedDescriptionComparator());
// then check they concur
for (int i = 0; i < sorted.size(); i++) {
assertEquals(sortedDescriptions.get(i), sorted.get(i).candidatePreferred);
}
}
}
|
20043683_1
|
class SnomedCodeComparator implements Comparator<SnomedConcept> {
public int compare(final SnomedConcept o1, final SnomedConcept o2) {
if (o1 == o2) return 0;
if (o1 != null) {
if (o2 == null) return 1;
// need to use BigInteger to compare SNOMED codes since some are fantastically long
else return new BigInteger(o1.snomedId)
.compareTo(new BigInteger(o2.snomedId));
}
return -1;
}
}
class SnomedCodeComparatorTest {
@Test
public void testCompare() throws Exception {
|
final List<SnomedConcept> sorted = new ArrayList<>(TestData.TEST_DATA);
Collections.sort(sorted, new SnomedCodeComparator());
for (int i = 0; i < sorted.size(); i++) {
assertEquals(sorted.get(i).candidateScore, i);
}
}
}
|
20043683_2
|
class MappingGroupComparator implements Comparator<SnomedConcept> {
public int compare(final SnomedConcept o1, final SnomedConcept o2) {
if (o1 == o2) return 0;
if (o1 != null) {
if (o2 == null) return 1;
// sort shorter mapping groups first
else if (o1.mappingGroup.length() != o2.mappingGroup.length()) {
return ((Integer)o1.mappingGroup.length()).compareTo(o2.mappingGroup.length());
}
else return o1.mappingGroup.compareTo(o2.mappingGroup);
}
return -1;
}
}
class MappingGroupComparatorTest {
@Test
public void testCompare() throws Exception {
|
final List<SnomedConcept> sorted = new ArrayList<>(TestData.TEST_DATA);
Collections.sort(sorted, new MappingGroupComparator());
for (int i = 0; i < sorted.size(); i++) {
assertEquals(sorted.get(i).candidateScore, i);
}
}
}
|
20043683_3
|
class SnomedRequestCallback implements RequestCallback {
static String nextMappingGroup(final String mappingGroup) {
if (mappingGroup == null || "".equals(mappingGroup)) return "A";
final char[] cs = mappingGroup.toCharArray();
boolean incrementFurther = true;
// step through the array backwards
for (int i = cs.length - 1; i >= 0; i--) {
// if we should no longer increment then break out of the loop
if (!incrementFurther) break;
// continue incrementing backwards through the array as long as we are finding Z's
if (++cs[i] > 'Z') cs[i] = 'A';
else incrementFurther = false;
}
final String result = new String(cs);
// if the first char of the array was a Z then we have a 'carry' operation and need to add another A at the end
if (incrementFurther) return result + "A";
else return result;
}
public SnomedRequestCallback(final List<SnomedConcept> conceptList, final Label statusLabel,
final GlassLoadingPanel glassPanel, final Map<String, String> typeCodeToDescription);
public void onError(final Request request, final Throwable e);
public void onResponseReceived(final Request request, final Response response);
}
class SnomedRequestCallbackTest {
@Test
public void testNextMappingGroup() throws Exception {
|
assertEquals(SnomedRequestCallback.nextMappingGroup(null), "A");
assertEquals(SnomedRequestCallback.nextMappingGroup(""), "A");
assertEquals(SnomedRequestCallback.nextMappingGroup("A"), "B");
assertEquals(SnomedRequestCallback.nextMappingGroup("B"), "C");
assertEquals(SnomedRequestCallback.nextMappingGroup("Z"), "AA");
assertEquals(SnomedRequestCallback.nextMappingGroup("AA"), "AB");
assertEquals(SnomedRequestCallback.nextMappingGroup("AC"), "AD");
assertEquals(SnomedRequestCallback.nextMappingGroup("AZ"), "BA");
assertEquals(SnomedRequestCallback.nextMappingGroup("BA"), "BB");
assertEquals(SnomedRequestCallback.nextMappingGroup("ZZ"), "AAA");
assertEquals(SnomedRequestCallback.nextMappingGroup("AAA"), "AAB");
assertEquals(SnomedRequestCallback.nextMappingGroup("AZA"), "AZB");
assertEquals(SnomedRequestCallback.nextMappingGroup("AZZ"), "BAA");
assertEquals(SnomedRequestCallback.nextMappingGroup("ZZZ"), "AAAA");
assertEquals(SnomedRequestCallback.nextMappingGroup("ABZZ"), "ACAA");
}
}
|
20043683_5
|
class MetaMapOptions {
@SuppressWarnings("ReturnOfNull")
public static Option strToOpt(final String optStr) {
final String[] parts = SPACE.split(optStr, 2);
final String name = parts[0];
final String param = 1 < parts.length ? parts[1] : null;
final Option opt = OPTS.get(name);
return opt == null ? null : opt.newInstance(param);
}
private MetaMapOptions();
static List<String> sanitiseAndSplit(final String param);
}
class MetaMapOptionsTest {
@Test
public void test() throws Exception {
|
final Option o1 = MetaMapOptions.strToOpt("foobar");
assertNull(o1);
final Option o2 = MetaMapOptions.strToOpt("word_sense_disambiguation");
assertNotNull(o2);
assertEquals(o2.getClass(), WordSenseDisambiguation.class);
assertEquals(o2.name(), "word_sense_disambiguation");
assertNull(o2.param());
assertEquals(o2.toMmOptStr(), "--word_sense_disambiguation");
final Option o3 = MetaMapOptions.strToOpt("composite_phrases");
assertNull(o3);
final Option o4 = MetaMapOptions.strToOpt("composite_phrases X");
assertNull(o4);
final Option o5 = MetaMapOptions.strToOpt("composite_phrases 20");
assertNull(o5);
final Option o6 = MetaMapOptions.strToOpt("composite_phrases 4");
assertNotNull(o6);
assertEquals(o6.getClass(), CompositePhrases.class);
assertEquals(o6.toMmOptStr(), "--composite_phrases 4");
}
}
|
20043683_6
|
class SemanticTypes {
public static Collection<String> sanitiseSemanticTypes(final Collection<String> semanticTypes) {
if (semanticTypes == null) return ImmutableList.of();
// check that each of the given types are in the map we have, otherwise throw it away
final Set<String> s = new LinkedHashSet<>(semanticTypes);
return s.retainAll(SEMANTIC_TYPES_CODE_TO_DESCRIPTION.keySet()) ? s : semanticTypes;
}
private SemanticTypes();
}
class SemanticTypesTest {
@Test
public void testSanitiseSemanticTypes() {
|
assertEquals(sanitiseSemanticTypes(null), of());
assertEquals(sanitiseSemanticTypes(ImmutableList.<String>of()), of());
assertEquals(sanitiseSemanticTypes(of("foobar")), of());
assertEquals(sanitiseSemanticTypes(of("dsyn")), of("dsyn"));
assertEquals(sanitiseSemanticTypes(of("dsyn", "foobar")),of("dsyn"));
assertEquals(sanitiseSemanticTypes(of("dsyn", "foobar", "fish")), of("dsyn", "fish"));
}
}
|
20043683_7
|
class JaxbLoader {
public static MMOs loadXml(final File xmlFile)
throws JAXBException, SAXException, ParserConfigurationException, FileNotFoundException {
final JAXBContext jaxbContext = JAXBContext.newInstance(MMOs.class);
final Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
// avoid getting the DTD (was mainly for when demoing without a network, but should maybe be kept?)
final SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setFeature("http://apache.org/xml/features/validation/schema", false);
spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
final XMLReader xmlReader = spf.newSAXParser().getXMLReader();
final InputSource inputSource = new InputSource(new FileReader(xmlFile));
final SAXSource source = new SAXSource(xmlReader, inputSource);
return (MMOs) jaxbUnmarshaller.unmarshal(source);
}
private static final File TEST_XML;
}
class JaxbLoaderTest {
private static final File TEST_XML;
@SuppressWarnings("OverlyBroadThrowsClause")
@Test
public void testLoadXml() throws Exception {
|
final MMOs root = JaxbLoader.loadXml(TEST_XML);
assertNotNull(root);
final MMO mmo = root.getMMO().get(0);
assertNotNull(mmo);
final Utterance utterance = mmo.getUtterances().getUtterance().get(0);
assertNotNull(utterance);
final Phrase phrase = utterance.getPhrases().getPhrase().get(0);
assertNotNull(phrase);
final Mapping mapping = phrase.getMappings().getMapping().get(0);
assertNotNull(mapping);
final Candidate candidate = mapping.getMappingCandidates().getCandidate().get(0);
assertNotNull(candidate);
assertEquals(candidate.getCandidateCUI(), "C0004096");
assertEquals(candidate.getCandidatePreferred(), "Asthma");
final SemType semType = candidate.getSemTypes().getSemType().get(0);
assertEquals(semType.getvalue(), "dsyn");
}
}
|
20043683_8
|
class JaxbLoader {
public static MMOs loadXml(final File xmlFile)
throws JAXBException, SAXException, ParserConfigurationException, FileNotFoundException {
final JAXBContext jaxbContext = JAXBContext.newInstance(MMOs.class);
final Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
// avoid getting the DTD (was mainly for when demoing without a network, but should maybe be kept?)
final SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setFeature("http://apache.org/xml/features/validation/schema", false);
spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
final XMLReader xmlReader = spf.newSAXParser().getXMLReader();
final InputSource inputSource = new InputSource(new FileReader(xmlFile));
final SAXSource source = new SAXSource(xmlReader, inputSource);
return (MMOs) jaxbUnmarshaller.unmarshal(source);
}
private static final File TEST_XML;
}
class JaxbLoaderTest {
private static final File TEST_XML;
@Test
public void failToLoad() {
|
//noinspection OverlyBroadCatchBlock
try {
JaxbLoader.loadXml(new File("noSuchFile"));
fail("We should have had an exception before now.");
}
catch (final FileNotFoundException ignored) {
// do nothing
}
catch (final Throwable t) {
//noinspection CallToPrintStackTrace
t.printStackTrace();
fail("There should be no other throwables.");
}
}
}
|
20186852_0
|
class SelectUtils {
public static void addExpression(Select select, final Expression expr) {
select.getSelectBody().accept(new SelectVisitor() {
public void visit(PlainSelect plainSelect) {
plainSelect.getSelectItems().add(new SelectExpressionItem(expr));
}
public void visit(SetOperationList setOpList) {
throw new UnsupportedOperationException("Not supported yet.");
}
public void visit(WithItem withItem) {
throw new UnsupportedOperationException("Not supported yet.");
}
});
}
private SelectUtils();
public static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr);
public static Select buildSelectFromTableAndExpressions(Table table, String ... expr);
public static Select buildSelectFromTableAndSelectItems(Table table, SelectItem ... selectItems);
public static Select buildSelectFromTable(Table table);
public static Join addJoin(Select select, final Table table, final Expression onExpression);
}
class SelectUtilsTest {
@Test
public void testAddExpr() throws JSQLParserException {
|
Select select = (Select) CCJSqlParserUtil.parse("select a from mytable");
SelectUtils.addExpression(select, new Column("b"));
assertEquals("SELECT a, b FROM mytable", select.toString());
Addition add = new Addition();
add.setLeftExpression(new LongValue(5));
add.setRightExpression(new LongValue(6));
SelectUtils.addExpression(select, add);
assertEquals("SELECT a, b, 5 + 6 FROM mytable", select.toString());
}
}
|
20186852_1
|
class SelectUtils {
public static Join addJoin(Select select, final Table table, final Expression onExpression) {
if (select.getSelectBody() instanceof PlainSelect) {
PlainSelect plainSelect = (PlainSelect) select.getSelectBody();
List<Join> joins = plainSelect.getJoins();
if (joins == null) {
joins = new ArrayList<Join>();
plainSelect.setJoins(joins);
}
Join join = new Join();
join.setRightItem(table);
join.setOnExpression(onExpression);
joins.add(join);
return join;
}
throw new UnsupportedOperationException("Not supported yet.");
}
private SelectUtils();
public static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr);
public static Select buildSelectFromTableAndExpressions(Table table, String ... expr);
public static Select buildSelectFromTableAndSelectItems(Table table, SelectItem ... selectItems);
public static Select buildSelectFromTable(Table table);
public static void addExpression(Select select, final Expression expr);
}
class SelectUtilsTest {
@Test
public void testAddJoin() throws JSQLParserException {
|
Select select = (Select)CCJSqlParserUtil.parse("select a from mytable");
final EqualsTo equalsTo = new EqualsTo();
equalsTo.setLeftExpression(new Column("a"));
equalsTo.setRightExpression(new Column("b"));
Join addJoin = SelectUtils.addJoin(select, new Table("mytable2"), equalsTo);
addJoin.setLeft(true);
assertEquals("SELECT a FROM mytable LEFT JOIN mytable2 ON a = b", select.toString());
}
}
|
20186852_3
|
class SelectUtils {
public static Select buildSelectFromTable(Table table) {
return buildSelectFromTableAndSelectItems(table, new AllColumns());
}
private SelectUtils();
public static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr);
public static Select buildSelectFromTableAndExpressions(Table table, String ... expr);
public static Select buildSelectFromTableAndSelectItems(Table table, SelectItem ... selectItems);
public static void addExpression(Select select, final Expression expr);
public static Join addJoin(Select select, final Table table, final Expression onExpression);
}
class SelectUtilsTest {
@Test
public void testBuildSelectFromTable() {
|
Select select = SelectUtils.buildSelectFromTable(new Table("mytable"));
assertEquals("SELECT * FROM mytable", select.toString());
}
}
|
20186852_5
|
class CCJSqlParserUtil {
public static Expression parseExpression(String expression) throws JSQLParserException {
CCJSqlParser parser = new CCJSqlParser(new StringReader(expression));
try {
return parser.SimpleExpression();
} catch (Exception ex) {
throw new JSQLParserException(ex);
}
}
private CCJSqlParserUtil();
public static Statement parse(Reader statementReader);
public static Statement parse(String sql);
public static Statement parse(InputStream is);
public static Statement parse(InputStream is, String encoding);
public static Expression parseCondExpression(String condExpr);
public static Statements parseStatements(String sqls);
}
class CCJSqlParserUtilTest {
@Test
public void testParseExpression() throws Exception {
|
Expression result = CCJSqlParserUtil.parseExpression("a+b");
assertEquals("a + b", result.toString());
assertTrue(result instanceof Addition);
Addition add = (Addition)result;
assertTrue(add.getLeftExpression() instanceof Column);
assertTrue(add.getRightExpression() instanceof Column);
}
}
|
20186852_6
|
class CCJSqlParserUtil {
public static Expression parseExpression(String expression) throws JSQLParserException {
CCJSqlParser parser = new CCJSqlParser(new StringReader(expression));
try {
return parser.SimpleExpression();
} catch (Exception ex) {
throw new JSQLParserException(ex);
}
}
private CCJSqlParserUtil();
public static Statement parse(Reader statementReader);
public static Statement parse(String sql);
public static Statement parse(InputStream is);
public static Statement parse(InputStream is, String encoding);
public static Expression parseCondExpression(String condExpr);
public static Statements parseStatements(String sqls);
}
class CCJSqlParserUtilTest {
@Test
public void testParseExpression2() throws Exception {
|
Expression result = CCJSqlParserUtil.parseExpression("2*(a+6.0)");
assertEquals("2 * (a + 6.0)", result.toString());
assertTrue(result instanceof Multiplication);
Multiplication mult = (Multiplication)result;
assertTrue(mult.getLeftExpression() instanceof LongValue);
assertTrue(mult.getRightExpression() instanceof Parenthesis);
}
}
|
20186852_7
|
class CCJSqlParserUtil {
public static Expression parseCondExpression(String condExpr) throws JSQLParserException {
CCJSqlParser parser = new CCJSqlParser(new StringReader(condExpr));
try {
return parser.Expression();
} catch (Exception ex) {
throw new JSQLParserException(ex);
}
}
private CCJSqlParserUtil();
public static Statement parse(Reader statementReader);
public static Statement parse(String sql);
public static Statement parse(InputStream is);
public static Statement parse(InputStream is, String encoding);
public static Expression parseExpression(String expression);
public static Statements parseStatements(String sqls);
}
class CCJSqlParserUtilTest {
@Test
public void testParseCondExpression() throws Exception {
|
Expression result = CCJSqlParserUtil.parseCondExpression("a+b>5 and c<3");
assertEquals("a + b > 5 AND c < 3", result.toString());
}
}
|
20186852_8
|
class SignedExpression implements Expression {
public char getSign() {
return sign;
}
public SignedExpression(char sign, Expression expression);
public final void setSign(char sign);
public Expression getExpression();
public final void setExpression(Expression expression);
public void accept(ExpressionVisitor expressionVisitor);
public String toString();
}
class SignedExpressionTest {
@Test(expected = IllegalArgumentException.class)
public void testGetSign() throws JSQLParserException {
|
new SignedExpression('*', CCJSqlParserUtil.parseExpression("a"));
fail("must not work");
}
}
|
21267129_0
|
class AbstractClient implements Closeable {
public static String getUrlEncodedValue(String value) {
try {
return StringUtils.replace(
new URLCodec().encode(StringUtils.trimToNull(value), getEncoding()),
"+", "%20");
} catch (UnsupportedEncodingException ex) {
LOGGER.error("Unsupported encoding!", ex);
return null;
}
}
protected AbstractClient(String apiBaseUrl, String consumerToken, String consumerSecret);
@SuppressWarnings("unused") public final void authorize(Authorization authorization);
@SuppressWarnings("RedundantThrows") public final void authorize(String accessToken, String accessSecret);
public final Authorization authorizeAfterVerification(Verification verification, String verificationCode);
public final Authorization authorizeAfterVerification(String verificationToken, String verificationSecret, String verificationCode);
protected OAuthConsumer buildOAuthConsumer(String token, String secret);
protected OAuthProvider buildOAuthProvider(String apiBaseUrl);
@Override public void close();
@SuppressWarnings("unused") public final Verification fetchVerification();
public final Verification fetchVerification(String callbackUrl);
public final String getApiBaseUrl();
public final OAuthConsumer getAuthConsumer();
public final OAuthProvider getAuthProvider();
public static String getEncoding();
@SuppressWarnings("unused") protected abstract Response sendJsonRequest(URL url, RequestMethod method, String json);
protected abstract Response sendXmlRequest(URL url, RequestMethod method, String xml);
@SuppressWarnings("SameParameterValue") protected abstract Response sendXmlAttachmentRequest(URL url, RequestMethod method, String xml, InputStream input, String fileName, String mimeType);
@SuppressWarnings("SameParameterValue") protected abstract Response sendVideoUploadRequest(URI url, RequestMethod method, String auth, InputStream input, String fileName, long fileSize);
@SuppressWarnings("unused")
private final static Logger LOGGER;
}
class AbstractClientTest {
@SuppressWarnings("unused")
private final static Logger LOGGER;
@Test
public void testGetUrlEncodedValue() {
|
Assert.assertEquals(
"1%2B2%3D3%20%C3%A4%C3%B6%C3%BC%C3%9F%20%2F%20%E2%82%AC%20%26",
AbstractClient.getUrlEncodedValue("1+2=3 äöüß / € &"));
}
}
|
21267129_1
|
class RandomStringUtils {
public static String random(int length) {
return new RandomStringGenerator.Builder()
.filteredBy(NUMBERS, LETTERS)
.build().generate(length);
}
private RandomStringUtils();
public static String randomLetters(int length);
public static String randomNumeric(int length);
@SuppressWarnings("unused")
private final static Logger LOGGER;
}
class RandomStringUtilsTest {
@SuppressWarnings("unused")
private final static Logger LOGGER;
@Test
public void testRandom() {
|
for (int length = 1; length < 10; length++) {
String value = RandomStringUtils.random(length);
//LOGGER.debug( "random alphanumeric string: " + value );
Assert.assertEquals(
"random string has a length of " + length,
length, value.length());
Assert.assertTrue(
"random string is alphanumeric",
isAsciiAlphanumeric(value));
}
}
}
|
21267129_2
|
class RandomStringUtils {
public static String randomLetters(int length) {
return new RandomStringGenerator.Builder()
.filteredBy(LETTERS)
.build().generate(length);
}
private RandomStringUtils();
public static String random(int length);
public static String randomNumeric(int length);
@SuppressWarnings("unused")
private final static Logger LOGGER;
}
class RandomStringUtilsTest {
@SuppressWarnings("unused")
private final static Logger LOGGER;
@Test
public void testRandomLetters() {
|
for (int length = 1; length < 10; length++) {
String value = RandomStringUtils.randomLetters(length);
//LOGGER.debug( "random alpha string: " + value );
Assert.assertEquals(
"random string has a length of " + length,
length, value.length());
Assert.assertTrue(
"random string is alpha",
isAsciiAlpha(value));
}
}
}
|
21267129_3
|
class RandomStringUtils {
public static String randomNumeric(int length) {
return new RandomStringGenerator.Builder()
.filteredBy(NUMBERS)
.build().generate(length);
}
private RandomStringUtils();
public static String random(int length);
public static String randomLetters(int length);
@SuppressWarnings("unused")
private final static Logger LOGGER;
}
class RandomStringUtilsTest {
@SuppressWarnings("unused")
private final static Logger LOGGER;
@Test
public void testRandomNumbers() {
|
for (int length = 1; length < 10; length++) {
String value = RandomStringUtils.randomNumeric(length);
//LOGGER.debug( "random numeric string: " + value );
Assert.assertEquals(
"random string has a length of " + length,
length, value.length());
Assert.assertTrue(
"random string is numeric",
isAsciiNumeric(value));
}
}
}
|
22169673_0
|
class ProxyHelper {
static boolean isHostMatchesNonProxyHostsPattern( String host, String nonProxyHostsPattern )
{
boolean matches = true;
if ( StringUtils.isNotBlank( nonProxyHostsPattern ) )
{
try
{
matches = host.matches( nonProxyHostsPattern );
}
catch ( PatternSyntaxException e )
{
String message = String.format( "Invalid pattern for non-proxy hosts: '%s'", nonProxyHostsPattern );
log.warn( message, e );
matches = false;
}
}
String format = "isHostMatchesNonProxyHostsPattern( host = '{}', nonProxyHostsPattern = '{}' ): {}";
log.debug( format, host, nonProxyHostsPattern, matches );
return matches;
}
private ProxyHelper( );
public static Proxy getProxy( String url );
private static boolean isUseProxy( String protocol, String host );
static boolean isUseProxyByPattern( String host, String nonProxyHostsPattern );
static String convertToJavaPattern( String pattern );
private static int getProxyPort( String protocol );
private static String getProxyHost( String protocol );
private static String getNonProxyHostsPattern( String protocol );
private static String getProxyPassword( String protocol );
private static String getProxyUser( String protocol );
static String getProtocol( String url );
static String getHost( String url );
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
}
class ProxyHelperTest {
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
@Test
public void testIsHostMatchesNonProxyHostsPattern( )
{
|
String javaPattern = ProxyHelper.convertToJavaPattern( PATTERN );
boolean matches = ProxyHelper.isHostMatchesNonProxyHostsPattern( HOST, javaPattern );
String message = String.format( "host '%s' must match pattern '%s'", HOST, PATTERN );
assertTrue( message, matches );
}
}
|
22169673_1
|
class ProxyHelper {
static String convertToJavaPattern( String pattern )
{
String javaPattern = pattern;
if ( StringUtils.isNotBlank( pattern ) )
{
javaPattern = javaPattern.replaceAll( "\\.", "\\\\." );
javaPattern = javaPattern.replaceAll( "\\*", ".*" );
}
log.debug( "convertToJavaPattern: javaPattern = '{}'", javaPattern );
return javaPattern;
}
private ProxyHelper( );
public static Proxy getProxy( String url );
private static boolean isUseProxy( String protocol, String host );
static boolean isUseProxyByPattern( String host, String nonProxyHostsPattern );
static boolean isHostMatchesNonProxyHostsPattern( String host, String nonProxyHostsPattern );
private static int getProxyPort( String protocol );
private static String getProxyHost( String protocol );
private static String getNonProxyHostsPattern( String protocol );
private static String getProxyPassword( String protocol );
private static String getProxyUser( String protocol );
static String getProtocol( String url );
static String getHost( String url );
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
}
class ProxyHelperTest {
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
@Test
public void testConvertToJavaPattern( )
{
|
String javaPattern = ProxyHelper.convertToJavaPattern( PATTERN );
String expected = "localhost|.*\\.my\\.company|192\\.168\\..*|127\\.0\\.0\\.1";
assertEquals( "javaPattern", expected, javaPattern );
}
}
|
22169673_2
|
class ProxyHelper {
static boolean isUseProxyByPattern( String host, String nonProxyHostsPattern )
{
String nonProxyHostsPatternJava = convertToJavaPattern( nonProxyHostsPattern );
boolean useProxy = !isHostMatchesNonProxyHostsPattern( host, nonProxyHostsPatternJava );
log.info( "isUseProxyByPattern: useProxy = {}; host = '{}'", useProxy, host );
return useProxy;
}
private ProxyHelper( );
public static Proxy getProxy( String url );
private static boolean isUseProxy( String protocol, String host );
static String convertToJavaPattern( String pattern );
static boolean isHostMatchesNonProxyHostsPattern( String host, String nonProxyHostsPattern );
private static int getProxyPort( String protocol );
private static String getProxyHost( String protocol );
private static String getNonProxyHostsPattern( String protocol );
private static String getProxyPassword( String protocol );
private static String getProxyUser( String protocol );
static String getProtocol( String url );
static String getHost( String url );
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
}
class ProxyHelperTest {
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
@Test
public void testIsUseProxyByPattern( )
{
|
boolean useProxyByPattern = ProxyHelper.isUseProxyByPattern( HOST, PATTERN );
assertFalse( "useProxyByPattern", useProxyByPattern );
}
}
|
22169673_3
|
class ProxyHelper {
static String getProtocol( String url )
{
log.debug( "getProtocol( url = '{}' )", url );
String protocol = DEFAULT_PROTOCOL;
try
{
URL u = new URL( url );
protocol = u.getProtocol( );
}
catch ( MalformedURLException e )
{
String message = String.format( "Failed to parse URL '%s'", url );
log.warn( message, e );
}
log.debug( "getProtocol( ): protocol = '{}'", protocol );
return protocol;
}
private ProxyHelper( );
public static Proxy getProxy( String url );
private static boolean isUseProxy( String protocol, String host );
static boolean isUseProxyByPattern( String host, String nonProxyHostsPattern );
static String convertToJavaPattern( String pattern );
static boolean isHostMatchesNonProxyHostsPattern( String host, String nonProxyHostsPattern );
private static int getProxyPort( String protocol );
private static String getProxyHost( String protocol );
private static String getNonProxyHostsPattern( String protocol );
private static String getProxyPassword( String protocol );
private static String getProxyUser( String protocol );
static String getHost( String url );
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
}
class ProxyHelperTest {
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
@Test
public void testGetProtocol( )
{
|
String protocol = ProxyHelper.getProtocol( SOURCE_URL );
assertEquals( "protocol", "https", protocol );
}
}
|
22169673_4
|
class ProxyHelper {
static String getHost( String url )
{
log.debug( "getHost( url = '{}' )", url );
String host = "";
try
{
URL u = new URL( url );
host = u.getHost( );
}
catch ( MalformedURLException e )
{
String message = String.format( "Failed to parse URL '%s'", url );
log.warn( message, e );
}
log.debug( "getHost( ): host = '{}'", host );
return host;
}
private ProxyHelper( );
public static Proxy getProxy( String url );
private static boolean isUseProxy( String protocol, String host );
static boolean isUseProxyByPattern( String host, String nonProxyHostsPattern );
static String convertToJavaPattern( String pattern );
static boolean isHostMatchesNonProxyHostsPattern( String host, String nonProxyHostsPattern );
private static int getProxyPort( String protocol );
private static String getProxyHost( String protocol );
private static String getNonProxyHostsPattern( String protocol );
private static String getProxyPassword( String protocol );
private static String getProxyUser( String protocol );
static String getProtocol( String url );
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
}
class ProxyHelperTest {
public static final String PATTERN;
public static final String HOST;
public static final String SOURCE_URL;
@Test
public void testGetHost( )
{
|
String host = ProxyHelper.getHost( SOURCE_URL );
assertEquals( "host", HOST, host );
}
}
|
22430702_0
|
class FormattedGraphParser {
public FormattedGraph parseFormattedGraph() throws InvalidConfigurationException {
if (formattedGraph != null) {
return formattedGraph;
}
parseBasicGraphConfiguration();
parseVertexPropertiesConfiguration();
parseEdgePropertiesConfiguration();
formattedGraph = new FormattedGraph(name, vertexCount, edgeCount, isDirected, vertexFilePath, edgeFilePath, vertexProperties, edgeProperties);
return formattedGraph;
}
public FormattedGraphParser(Configuration graphConfigurationSubset, String name, String graphRootDirectory);
private void parseBasicGraphConfiguration();
private void parseVertexPropertiesConfiguration();
private void parseEdgePropertiesConfiguration();
private static PropertyList parsePropertyList(Configuration config, String errorMessagePropertyKind, String errorMessageGraphName);
private String resolveGraphPath(String relativePath);
}
class FormattedGraphParserTest {
@Test
public void testParseGraphOnBasicConfiguration() throws InvalidConfigurationException {
|
final String ROOT_DIR = "graph-root-dir";
final Fixture FIXTURE = constructBasicGraph(ROOT_DIR);
FormattedGraphParser parser = new FormattedGraphParser(FIXTURE.getConfiguration(),
FIXTURE.getGraphName(), ROOT_DIR);
assertGraphEqual(FIXTURE.getExpectedGraph(), parser.parseFormattedGraph());
}
}
|
22430702_1
|
class FormattedGraphParser {
public FormattedGraph parseFormattedGraph() throws InvalidConfigurationException {
if (formattedGraph != null) {
return formattedGraph;
}
parseBasicGraphConfiguration();
parseVertexPropertiesConfiguration();
parseEdgePropertiesConfiguration();
formattedGraph = new FormattedGraph(name, vertexCount, edgeCount, isDirected, vertexFilePath, edgeFilePath, vertexProperties, edgeProperties);
return formattedGraph;
}
public FormattedGraphParser(Configuration graphConfigurationSubset, String name, String graphRootDirectory);
private void parseBasicGraphConfiguration();
private void parseVertexPropertiesConfiguration();
private void parseEdgePropertiesConfiguration();
private static PropertyList parsePropertyList(Configuration config, String errorMessagePropertyKind, String errorMessageGraphName);
private String resolveGraphPath(String relativePath);
}
class FormattedGraphParserTest {
@Test
public void testParseGraphOnVertexPropertiesConfiguration() throws InvalidConfigurationException {
|
final String ROOT_DIR = "graph-root-dir";
final Fixture FIXTURE = constructVertexPropertyGraph(ROOT_DIR);
FormattedGraphParser parser = new FormattedGraphParser(FIXTURE.getConfiguration(),
FIXTURE.getGraphName(), ROOT_DIR);
assertGraphEqual(FIXTURE.getExpectedGraph(), parser.parseFormattedGraph());
}
}
|
22430702_2
|
class FormattedGraphParser {
public FormattedGraph parseFormattedGraph() throws InvalidConfigurationException {
if (formattedGraph != null) {
return formattedGraph;
}
parseBasicGraphConfiguration();
parseVertexPropertiesConfiguration();
parseEdgePropertiesConfiguration();
formattedGraph = new FormattedGraph(name, vertexCount, edgeCount, isDirected, vertexFilePath, edgeFilePath, vertexProperties, edgeProperties);
return formattedGraph;
}
public FormattedGraphParser(Configuration graphConfigurationSubset, String name, String graphRootDirectory);
private void parseBasicGraphConfiguration();
private void parseVertexPropertiesConfiguration();
private void parseEdgePropertiesConfiguration();
private static PropertyList parsePropertyList(Configuration config, String errorMessagePropertyKind, String errorMessageGraphName);
private String resolveGraphPath(String relativePath);
}
class FormattedGraphParserTest {
@Test
public void testParseGraphOnEdgePropertiesConfiguration() throws InvalidConfigurationException {
|
final String ROOT_DIR = "graph-root-dir";
final Fixture FIXTURE = constructEdgePropertyGraph(ROOT_DIR);
FormattedGraphParser parser = new FormattedGraphParser(FIXTURE.getConfiguration(),
FIXTURE.getGraphName(), ROOT_DIR);
assertGraphEqual(FIXTURE.getExpectedGraph(), parser.parseFormattedGraph());
}
}
|
22430702_3
|
class EdgeListStreamWriter implements AutoCloseable {
public void writeAll() throws IOException {
while (inputStream.hasNextEdge()) {
writeNextEdge();
}
outputWriter.flush();
}
public EdgeListStreamWriter(EdgeListStream inputStream, OutputStream outputStream);
private void writeNextEdge();
@Override public void close();
private static final EdgeListStream.EdgeData[] edges;
private static final String expectedOutput;
}
class EdgeListStreamWriterTest {
private static final EdgeListStream.EdgeData[] edges;
private static final String expectedOutput;
@Test
public void testWriteAllOnMockEdgeListStream() throws IOException {
|
EdgeListStream edgeListStream = new MockEdgeListStream(edges);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try (EdgeListStreamWriter writer = new EdgeListStreamWriter(edgeListStream, outputStream)) {
writer.writeAll();
assertEquals("Output of EdgeListStreamWriter is correct", expectedOutput, outputStream.toString());
}
}
}
|
22430702_4
|
class VertexListInputStreamReader implements VertexListStream {
@Override
public boolean hasNextVertex() throws IOException {
if (cacheValid) {
return true;
} else {
for (String line = reader.readLine(); line != null; line = reader.readLine()) {
line = line.trim();
if (line.isEmpty()) {
continue;
}
String[] tokens = line.split(" ");
try {
cache.setId(Long.parseLong(tokens[0]));
} catch (NumberFormatException ex) {
throw new IOException("Failed to parse vertex identifier from stream.", ex);
}
if (cache.getValues().length == tokens.length - 1) {
System.arraycopy(tokens, 1, cache.getValues(), 0, tokens.length - 1);
} else {
cache.setValues(Arrays.copyOfRange(tokens, 1, tokens.length));
}
cacheValid = true;
return true;
}
return false;
}
}
public VertexListInputStreamReader(InputStream inputStream);
@Override public VertexData getNextVertex();
@Override public void close();
}
class VertexListInputStreamReaderTest {
@Test
public void testHasNextVertexOnEmptyLines() throws IOException {
|
String input = "\n \n \n";
InputStream inputStream = new ByteArrayInputStream(input.getBytes());
try (VertexListInputStreamReader reader = new VertexListInputStreamReader(inputStream)) {
assertFalse(reader.hasNextVertex());
}
}
}
|
22430702_5
|
class EdgeListInputStreamReader implements EdgeListStream {
@Override
public boolean hasNextEdge() throws IOException {
if (cacheValid) {
return true;
} else {
for (String line = reader.readLine(); line != null; line = reader.readLine()) {
line = line.trim();
if (line.isEmpty()) {
continue;
}
String[] tokens = line.split(" ");
if (tokens.length < 2) {
throw new IOException("Malformed edge data in stream: \"" + line + "\".");
}
try {
cache.setSourceId(Long.parseLong(tokens[0]));
cache.setDestinationId(Long.parseLong(tokens[1]));
} catch (NumberFormatException ex) {
throw new IOException("Failed to parse vertex identifier from stream.", ex);
}
if (cache.getValues().length == tokens.length - 2) {
System.arraycopy(tokens, 2, cache.getValues(), 0, tokens.length - 2);
} else {
cache.setValues(Arrays.copyOfRange(tokens, 2, tokens.length));
}
cacheValid = true;
return true;
}
return false;
}
}
public EdgeListInputStreamReader(InputStream inputStream);
@Override public EdgeData getNextEdge();
@Override public void close();
}
class EdgeListInputStreamReaderTest {
@Test
public void testHasNextEdgeOnEmptyLines() throws IOException {
|
String input = "\n \n \n";
InputStream inputStream = new ByteArrayInputStream(input.getBytes());
try (EdgeListInputStreamReader reader = new EdgeListInputStreamReader(inputStream)) {
assertFalse(reader.hasNextEdge());
}
}
}
|
22430702_6
|
class VertexListStreamWriter implements AutoCloseable {
public void writeAll() throws IOException {
while (inputStream.hasNextVertex()) {
writeNextVertex();
}
outputWriter.flush();
}
public VertexListStreamWriter(VertexListStream inputStream, OutputStream outputStream);
private void writeNextVertex();
@Override public void close();
private static final VertexListStream.VertexData[] vertices;
private static final String expectedOutput;
}
class VertexListStreamWriterTest {
private static final VertexListStream.VertexData[] vertices;
private static final String expectedOutput;
@Test
public void testWriteAllOnMockVertexListStream() throws IOException {
|
VertexListStream vertexListStream = new MockVertexListStream(vertices);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try (VertexListStreamWriter writer = new VertexListStreamWriter(vertexListStream, outputStream)) {
writer.writeAll();
assertEquals("Output of VertexListStreamWriter is correct", expectedOutput, outputStream.toString());
}
}
}
|
22460817_0
|
class Str {
public static String trim(String s) {
if (s == null)
return null;
s = s.trim();
return s.length() > 0 ? s : null;
}
public static String group(String text, String regexp);
public static String group(String text, String regexp, int group);
public static Pair<String, String> groups(String text, String regexp, int group1, int group2);
public static boolean containsSpaces(String ... strings);
public static String lower(String s);
public static String upper(String s);
}
class StrTest {
@Test
public void trim() {
|
assertNull(Str.trim(null));
assertNull(Str.trim(""));
assertNull(Str.trim(" "));
assertNull(Str.trim(" \t\n "));
assertNotNull(Str.trim("."));
assertNotNull(Str.trim(" . "));
}
}
|
22460817_1
|
class Str {
public static String group(String text, String regexp) {
return group(text, regexp, 1);
}
public static String trim(String s);
public static String group(String text, String regexp, int group);
public static Pair<String, String> groups(String text, String regexp, int group1, int group2);
public static boolean containsSpaces(String ... strings);
public static String lower(String s);
public static String upper(String s);
}
class StrTest {
@Test
public void group() {
|
assertNull("asdf : a -> null", Str.group("asdf", "a"));
assertNull("asdf : q -> null", Str.group("asdf", "q"));
assertEquals("asdf : (s) -> s", Str.group("asdf", "(s)"), "s");
assertEquals("asdf : ^.(..) -> sd", Str.group("asdf", "^.(..)"), "sd");
assertNull("asdf : ^.{5}(.+) -> null", Str.group("asdf", "^.{5}(.+)"));
}
}
|
2280644_13
|
class FileUtils {
public static void saveFile(Resource file, String text, boolean append) throws IOException {
if(file.isDirectory()) {
throw new IOException(file+": Is a directory");
}
try (OutputStream out = file.write(append);) {
out.write(text.getBytes());
}
}
private Resource resource;
private AeshContext aeshContext;
}
class FileUtilsTest {
private Resource resource;
private AeshContext aeshContext;
@Test
public void testSaveFile() throws IOException {
|
File file = File.createTempFile("tmp", ".tmp");
file.delete();
file.mkdir();
file.deleteOnExit();
File child = new File(file, "child.txt");
child.createNewFile();
child.deleteOnExit();
aeshContext.setCurrentWorkingDirectory(new FileResource(file));
resource = aeshContext.getCurrentWorkingDirectory();
FileUtils.saveFile(resource.list().get(0), "foo", false);
File f = new File(resource.list().get(0).getAbsolutePath());
Assert.assertEquals(new String(Files.readAllBytes(f.toPath())), "foo");
}
}
|
2280644_14
|
class FileCompleterGenerator {
String generateCompleterFile(CommandLineParser<CommandInvocation> command) {
StringBuilder out = new StringBuilder();
out.append(generateHeader(command.getProcessedCommand().name()));
if(command.isGroupCommand())
out.append(generateArrContains());
out.append(generateMainCompletion(command));
out.append(generateCommand(command)) ;
if(command.isGroupCommand())
for(CommandLineParser<CommandInvocation> child : command.getAllChildParsers())
out.append(generateCommand(child));
out.append(generateFooter(command.getProcessedCommand().name()));
return out.toString();
}
private String generateMainCompletion(CommandLineParser<CommandInvocation> command);
private String generateCommand(CommandLineParser<CommandInvocation> command);
private String generateCompletionValues(CommandLineParser<CommandInvocation> command);
private String generateHeader(String name);
private String generateFooter(String name);
private String generateArrContains();
private String generateDefaultCompletionVariables();
}
class FileCompleterGeneratorTest {
@Test
public void testSimpleCommand() {
|
CommandLineParser<CommandInvocation> parser = getParser(TestCommand1.class);
FileCompleterGenerator completerGenerator = new FileCompleterGenerator();
String out = completerGenerator.generateCompleterFile(parser);
assertTrue(out.contains("_complete_test1"));
assertTrue(out.contains("NO_VALUE_OPTIONS=\"--help -h \""));
assertTrue(out.contains("VALUE_OPTIONS=\"--override -o --test -t \""));
}
}
|
2280644_15
|
class FileCompleterGenerator {
String generateCompleterFile(CommandLineParser<CommandInvocation> command) {
StringBuilder out = new StringBuilder();
out.append(generateHeader(command.getProcessedCommand().name()));
if(command.isGroupCommand())
out.append(generateArrContains());
out.append(generateMainCompletion(command));
out.append(generateCommand(command)) ;
if(command.isGroupCommand())
for(CommandLineParser<CommandInvocation> child : command.getAllChildParsers())
out.append(generateCommand(child));
out.append(generateFooter(command.getProcessedCommand().name()));
return out.toString();
}
private String generateMainCompletion(CommandLineParser<CommandInvocation> command);
private String generateCommand(CommandLineParser<CommandInvocation> command);
private String generateCompletionValues(CommandLineParser<CommandInvocation> command);
private String generateHeader(String name);
private String generateFooter(String name);
private String generateArrContains();
private String generateDefaultCompletionVariables();
}
class FileCompleterGeneratorTest {
@Test
public void testGroupCommand() {
|
CommandLineParser<CommandInvocation> parser = getParser(GutCommand1.class);
FileCompleterGenerator completerGenerator = new FileCompleterGenerator();
String out = completerGenerator.generateCompleterFile(parser);
assertTrue(out.contains("_complete_gut"));
assertTrue(out.contains("_command_gut"));
assertTrue(out.contains("_command_help"));
assertTrue(out.contains("_command_rebase"));
assertTrue(out.contains("ArrContains"));
assertTrue(out.contains("ArrContains COMP_WORDS CHILD0 && { _command_help; return $?; }"));
}
}
|
2280644_16
|
class PathResolver {
@SuppressWarnings("IndexOfReplaceableByContains")
public static List<File> resolvePath(File incPath, File cwd) {
if(cwd == null)
cwd = new File(Config.getHomeDir());
//if incPath start with eg: ./, remove it
if(incPath.toString().startsWith(CURRENT_WITH_SEPARATOR)) {
incPath = new File(incPath.toString().substring(CURRENT_WITH_SEPARATOR.length()));
}
if(incPath.toString().startsWith(TILDE_WITH_SEPARATOR)) {
if(Config.getHomeDir().endsWith(Config.getPathSeparator()))
incPath = new File(Config.getHomeDir()+incPath.toString().substring(2));
else
incPath = new File(Config.getHomeDir()+incPath.toString().substring(1));
}
if(incPath.toString().indexOf(TILDE) == 0) {
if(incPath.toString().length() > 1) {
// directories which name starts with tilde
incPath = new File(cwd.toString() + Config.getPathSeparator() + incPath.toString());
} else {
incPath = new File(Config.getHomeDir());
}
}
// foo1/./foo2 is changed to foo1/foo2
if(incPath.toString().indexOf(SEPARATOR_CURRENT_SEPARATOR) > -1) {
int index = incPath.toString().indexOf(SEPARATOR_CURRENT_SEPARATOR);
if(index == 0) {
incPath = new File(incPath.toString().substring(SEPARATOR_CURRENT_SEPARATOR.length()-1));
}
else {
incPath = new File(incPath.toString().substring(0, index) +
incPath.toString().substring(index+2, incPath.toString().length()));
}
}
//parentPath do not start with / or by a windows driver letter and cwd is not / either
if( incPath.toString().indexOf(ROOT) != 0 && incPath.toString().indexOf(DRIVER_SEPARATOR) == -1 && !cwd.toString().equals(ROOT)) {
if(cwd.toString().endsWith(Config.getPathSeparator()))
incPath = new File(cwd.toString() + incPath.toString());
else
incPath = new File(cwd.toString() + Config.getPathSeparator() + incPath.toString());
}
if(incPath.toString().indexOf(PARENT_WITH_SEPARATOR) > -1) {
String tmp = incPath.toString();
while(tmp.indexOf(PARENT_WITH_SEPARATOR) > -1) {
int index = tmp.indexOf(PARENT_WITH_SEPARATOR);
if(index == 0) {
tmp = tmp.substring(PARENT_WITH_SEPARATOR.length());
}
else {
File tmpFile = new File(tmp.substring(0, index));
tmpFile = tmpFile.getParentFile();
if(tmpFile == null)
tmpFile = new File(Config.getPathSeparator());
tmpFile = new File(tmpFile.toString() + tmp.substring(index+ PARENT_WITH_SEPARATOR.length()-1));
//tmp = tmp.substring(0, index) + tmp.substring(index+PARENT_WITH_SEPARATOR.length());
tmp = tmpFile.toString();
}
}
incPath = new File(tmp);
}
if(incPath.toString().endsWith(PARENT)) {
incPath = new File(incPath.toString().substring(0, incPath.toString().length()-PARENT.length()));
incPath = incPath.getParentFile();
if(incPath == null)
incPath = new File(Config.getPathSeparator());
}
if( incPath.toString().indexOf(STAR) > -1 || incPath.toString().indexOf(WILDCARD) > -1) {
PathCriteria pathCriteria = parsePath(incPath);
if(incPath.toString().indexOf(SEPARATOR) > -1) {
List<File> foundFiles = null;
if(pathCriteria.getCriteria().equals(String.valueOf(STAR))) {
foundFiles = new ArrayList<>();
foundFiles.add(new File(pathCriteria.getParentPath()));
}
else
foundFiles = findFiles(new File(pathCriteria.parentPath), pathCriteria.getCriteria(), false);
if(pathCriteria.childPath.length() == 0)
return foundFiles;
else {
List<File> outFiles = new ArrayList<>();
for(File f : foundFiles)
if(new File(f+Config.getPathSeparator()+pathCriteria.childPath).exists())
outFiles.add(new File(f+Config.getPathSeparator()+pathCriteria.childPath));
return outFiles;
}
}
//just wildcard without separators
else {
if(incPath.toString().length() == 1) {
List<File> foundFiles = findFiles(new File(pathCriteria.parentPath), pathCriteria.getCriteria(), false);
if(pathCriteria.childPath.length() == 0)
return foundFiles;
}
return new ArrayList<File>();
}
}
else {
//no wildcards
ArrayList<File> fileList = new ArrayList<>(1);
fileList.add(incPath);
return fileList;
}
}
private static List<File> parseWildcard(File incPath);
private static List<File> findFiles(File incPath, String searchArgument, boolean findDirectory);
private static PathCriteria parsePath(File path);
private Path tempDir;
private static final FileAttribute fileAttribute;
}
class PathResolverTest {
private Path tempDir;
private static final FileAttribute fileAttribute;
@Test
public void testListFiles() {
|
File tmp = tempDir.toFile();
File child1 = new File(tmp + Config.getPathSeparator()+"child1");
File child2 = new File(tmp + Config.getPathSeparator()+"child2");
File child11 = new File(child1 + Config.getPathSeparator()+"child11");
File child12 = new File(child1 + Config.getPathSeparator()+"child12");
File child21 = new File(child1 + Config.getPathSeparator()+"child21");
File child22 = new File(child1 + Config.getPathSeparator()+"child22");
assertEquals(child1, PathResolver.resolvePath(new File(""), child1).get(0));
assertEquals(child1, PathResolver.resolvePath(new File(".."), child11).get(0));
assertEquals(child1, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()), child11).get(0));
assertEquals(tmp, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+".."), child11).get(0));
assertEquals(tmp, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+
".."+Config.getPathSeparator()), child11).get(0));
if(Config.isOSPOSIXCompatible()) {
assertEquals(tmp.getParentFile(), PathResolver.resolvePath(new File("../../../"), child11).get(0));
assertEquals(tmp.getParentFile().getParentFile(),
PathResolver.resolvePath(new File("../../../../"), child11).get(0));
// assertEquals(tmp.getParentFile().getParentFile(),
// PathResolver.resolvePath(new File("../../../../../"), child11).get(0));
// assertEquals(tmp.getParentFile().getParentFile(),
// PathResolver.resolvePath(new File("../../../../../.."), child11).get(0));
}
assertEquals(child11, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+"child11"), child11).get(0));
assertEquals(child1, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+".."+Config.getPathSeparator()+"child1"),
child11).get(0));
assertEquals(child11, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+".."+
Config.getPathSeparator()+"child1"+Config.getPathSeparator()+"child11"), child11).get(0));
assertEquals(tmp, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+".."+
Config.getPathSeparator()+".."+Config.getPathSeparator()+tmp.getName()), child11).get(0));
assertEquals(child11, PathResolver.resolvePath(new File("child11"), child1).get(0));
assertEquals(child11, PathResolver.resolvePath(new File("child1"+Config.getPathSeparator()+"child11"), tmp).get(0));
assertEquals(child11, PathResolver.resolvePath(new File("."+Config.getPathSeparator()+"child11"), child1).get(0));
assertEquals(child1, PathResolver.resolvePath(
new File(".."+Config.getPathSeparator()+"child1"+Config.getPathSeparator()), child1).get(0));
assertEquals(child1, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+"child1"+
Config.getPathSeparator()+".."+Config.getPathSeparator()+"child1"), child1).get(0));
assertEquals(child11, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+"child1"+
Config.getPathSeparator()+".."+Config.getPathSeparator()+"child1"+Config.getPathSeparator()+"child11"), child1).get(0));
assertEquals(child11, PathResolver.resolvePath(new File(".."+Config.getPathSeparator()+
"child1"+Config.getPathSeparator()+"."+Config.getPathSeparator()+"child11"), child1).get(0));
assertEquals(child11, PathResolver.resolvePath(new File("."+Config.getPathSeparator()+".."+
Config.getPathSeparator()+"child1"+Config.getPathSeparator()+"."+Config.getPathSeparator()+"child11"), child1).get(0));
System.setProperty("user.home", tempDir.toString()+Config.getPathSeparator()+"home");
assertEquals(new File(Config.getHomeDir()), PathResolver.resolvePath(new File("~/../home"), child1).get(0));
assertEquals(new File(Config.getHomeDir()), PathResolver.resolvePath(new File("~"), child1).get(0));
assertEquals(new File(child1, "~a"), PathResolver.resolvePath(new File("~a"), child1).get(0));
}
}
|
2280644_17
|
class PathResolver {
@SuppressWarnings("IndexOfReplaceableByContains")
public static List<File> resolvePath(File incPath, File cwd) {
if(cwd == null)
cwd = new File(Config.getHomeDir());
//if incPath start with eg: ./, remove it
if(incPath.toString().startsWith(CURRENT_WITH_SEPARATOR)) {
incPath = new File(incPath.toString().substring(CURRENT_WITH_SEPARATOR.length()));
}
if(incPath.toString().startsWith(TILDE_WITH_SEPARATOR)) {
if(Config.getHomeDir().endsWith(Config.getPathSeparator()))
incPath = new File(Config.getHomeDir()+incPath.toString().substring(2));
else
incPath = new File(Config.getHomeDir()+incPath.toString().substring(1));
}
if(incPath.toString().indexOf(TILDE) == 0) {
if(incPath.toString().length() > 1) {
// directories which name starts with tilde
incPath = new File(cwd.toString() + Config.getPathSeparator() + incPath.toString());
} else {
incPath = new File(Config.getHomeDir());
}
}
// foo1/./foo2 is changed to foo1/foo2
if(incPath.toString().indexOf(SEPARATOR_CURRENT_SEPARATOR) > -1) {
int index = incPath.toString().indexOf(SEPARATOR_CURRENT_SEPARATOR);
if(index == 0) {
incPath = new File(incPath.toString().substring(SEPARATOR_CURRENT_SEPARATOR.length()-1));
}
else {
incPath = new File(incPath.toString().substring(0, index) +
incPath.toString().substring(index+2, incPath.toString().length()));
}
}
//parentPath do not start with / or by a windows driver letter and cwd is not / either
if( incPath.toString().indexOf(ROOT) != 0 && incPath.toString().indexOf(DRIVER_SEPARATOR) == -1 && !cwd.toString().equals(ROOT)) {
if(cwd.toString().endsWith(Config.getPathSeparator()))
incPath = new File(cwd.toString() + incPath.toString());
else
incPath = new File(cwd.toString() + Config.getPathSeparator() + incPath.toString());
}
if(incPath.toString().indexOf(PARENT_WITH_SEPARATOR) > -1) {
String tmp = incPath.toString();
while(tmp.indexOf(PARENT_WITH_SEPARATOR) > -1) {
int index = tmp.indexOf(PARENT_WITH_SEPARATOR);
if(index == 0) {
tmp = tmp.substring(PARENT_WITH_SEPARATOR.length());
}
else {
File tmpFile = new File(tmp.substring(0, index));
tmpFile = tmpFile.getParentFile();
if(tmpFile == null)
tmpFile = new File(Config.getPathSeparator());
tmpFile = new File(tmpFile.toString() + tmp.substring(index+ PARENT_WITH_SEPARATOR.length()-1));
//tmp = tmp.substring(0, index) + tmp.substring(index+PARENT_WITH_SEPARATOR.length());
tmp = tmpFile.toString();
}
}
incPath = new File(tmp);
}
if(incPath.toString().endsWith(PARENT)) {
incPath = new File(incPath.toString().substring(0, incPath.toString().length()-PARENT.length()));
incPath = incPath.getParentFile();
if(incPath == null)
incPath = new File(Config.getPathSeparator());
}
if( incPath.toString().indexOf(STAR) > -1 || incPath.toString().indexOf(WILDCARD) > -1) {
PathCriteria pathCriteria = parsePath(incPath);
if(incPath.toString().indexOf(SEPARATOR) > -1) {
List<File> foundFiles = null;
if(pathCriteria.getCriteria().equals(String.valueOf(STAR))) {
foundFiles = new ArrayList<>();
foundFiles.add(new File(pathCriteria.getParentPath()));
}
else
foundFiles = findFiles(new File(pathCriteria.parentPath), pathCriteria.getCriteria(), false);
if(pathCriteria.childPath.length() == 0)
return foundFiles;
else {
List<File> outFiles = new ArrayList<>();
for(File f : foundFiles)
if(new File(f+Config.getPathSeparator()+pathCriteria.childPath).exists())
outFiles.add(new File(f+Config.getPathSeparator()+pathCriteria.childPath));
return outFiles;
}
}
//just wildcard without separators
else {
if(incPath.toString().length() == 1) {
List<File> foundFiles = findFiles(new File(pathCriteria.parentPath), pathCriteria.getCriteria(), false);
if(pathCriteria.childPath.length() == 0)
return foundFiles;
}
return new ArrayList<File>();
}
}
else {
//no wildcards
ArrayList<File> fileList = new ArrayList<>(1);
fileList.add(incPath);
return fileList;
}
}
private static List<File> parseWildcard(File incPath);
private static List<File> findFiles(File incPath, String searchArgument, boolean findDirectory);
private static PathCriteria parsePath(File path);
private Path tempDir;
private static final FileAttribute fileAttribute;
}
class PathResolverTest {
private Path tempDir;
private static final FileAttribute fileAttribute;
@Test
public void testWildcards() throws IOException {
|
File tmp = tempDir.toFile();
File child1 = new File(tempDir + Config.getPathSeparator()+"child1");
File child2 = new File(tempDir + Config.getPathSeparator()+"child2");
File child3 = new File(tempDir + Config.getPathSeparator()+"child3");
if(Config.isOSPOSIXCompatible()) {
Files.createDirectory(child1.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child2.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child3.toPath(), fileAttribute).toFile().deleteOnExit();
}
else {
Files.createDirectory(child1.toPath()).toFile().deleteOnExit();
Files.createDirectory(child2.toPath()).toFile().deleteOnExit();
Files.createDirectory(child3.toPath()).toFile().deleteOnExit();
}
List<File> files = PathResolver.resolvePath(new File("*"), tmp);
assertEquals(1, files.size());
}
}
|
2280644_18
|
class PathResolver {
@SuppressWarnings("IndexOfReplaceableByContains")
public static List<File> resolvePath(File incPath, File cwd) {
if(cwd == null)
cwd = new File(Config.getHomeDir());
//if incPath start with eg: ./, remove it
if(incPath.toString().startsWith(CURRENT_WITH_SEPARATOR)) {
incPath = new File(incPath.toString().substring(CURRENT_WITH_SEPARATOR.length()));
}
if(incPath.toString().startsWith(TILDE_WITH_SEPARATOR)) {
if(Config.getHomeDir().endsWith(Config.getPathSeparator()))
incPath = new File(Config.getHomeDir()+incPath.toString().substring(2));
else
incPath = new File(Config.getHomeDir()+incPath.toString().substring(1));
}
if(incPath.toString().indexOf(TILDE) == 0) {
if(incPath.toString().length() > 1) {
// directories which name starts with tilde
incPath = new File(cwd.toString() + Config.getPathSeparator() + incPath.toString());
} else {
incPath = new File(Config.getHomeDir());
}
}
// foo1/./foo2 is changed to foo1/foo2
if(incPath.toString().indexOf(SEPARATOR_CURRENT_SEPARATOR) > -1) {
int index = incPath.toString().indexOf(SEPARATOR_CURRENT_SEPARATOR);
if(index == 0) {
incPath = new File(incPath.toString().substring(SEPARATOR_CURRENT_SEPARATOR.length()-1));
}
else {
incPath = new File(incPath.toString().substring(0, index) +
incPath.toString().substring(index+2, incPath.toString().length()));
}
}
//parentPath do not start with / or by a windows driver letter and cwd is not / either
if( incPath.toString().indexOf(ROOT) != 0 && incPath.toString().indexOf(DRIVER_SEPARATOR) == -1 && !cwd.toString().equals(ROOT)) {
if(cwd.toString().endsWith(Config.getPathSeparator()))
incPath = new File(cwd.toString() + incPath.toString());
else
incPath = new File(cwd.toString() + Config.getPathSeparator() + incPath.toString());
}
if(incPath.toString().indexOf(PARENT_WITH_SEPARATOR) > -1) {
String tmp = incPath.toString();
while(tmp.indexOf(PARENT_WITH_SEPARATOR) > -1) {
int index = tmp.indexOf(PARENT_WITH_SEPARATOR);
if(index == 0) {
tmp = tmp.substring(PARENT_WITH_SEPARATOR.length());
}
else {
File tmpFile = new File(tmp.substring(0, index));
tmpFile = tmpFile.getParentFile();
if(tmpFile == null)
tmpFile = new File(Config.getPathSeparator());
tmpFile = new File(tmpFile.toString() + tmp.substring(index+ PARENT_WITH_SEPARATOR.length()-1));
//tmp = tmp.substring(0, index) + tmp.substring(index+PARENT_WITH_SEPARATOR.length());
tmp = tmpFile.toString();
}
}
incPath = new File(tmp);
}
if(incPath.toString().endsWith(PARENT)) {
incPath = new File(incPath.toString().substring(0, incPath.toString().length()-PARENT.length()));
incPath = incPath.getParentFile();
if(incPath == null)
incPath = new File(Config.getPathSeparator());
}
if( incPath.toString().indexOf(STAR) > -1 || incPath.toString().indexOf(WILDCARD) > -1) {
PathCriteria pathCriteria = parsePath(incPath);
if(incPath.toString().indexOf(SEPARATOR) > -1) {
List<File> foundFiles = null;
if(pathCriteria.getCriteria().equals(String.valueOf(STAR))) {
foundFiles = new ArrayList<>();
foundFiles.add(new File(pathCriteria.getParentPath()));
}
else
foundFiles = findFiles(new File(pathCriteria.parentPath), pathCriteria.getCriteria(), false);
if(pathCriteria.childPath.length() == 0)
return foundFiles;
else {
List<File> outFiles = new ArrayList<>();
for(File f : foundFiles)
if(new File(f+Config.getPathSeparator()+pathCriteria.childPath).exists())
outFiles.add(new File(f+Config.getPathSeparator()+pathCriteria.childPath));
return outFiles;
}
}
//just wildcard without separators
else {
if(incPath.toString().length() == 1) {
List<File> foundFiles = findFiles(new File(pathCriteria.parentPath), pathCriteria.getCriteria(), false);
if(pathCriteria.childPath.length() == 0)
return foundFiles;
}
return new ArrayList<File>();
}
}
else {
//no wildcards
ArrayList<File> fileList = new ArrayList<>(1);
fileList.add(incPath);
return fileList;
}
}
private static List<File> parseWildcard(File incPath);
private static List<File> findFiles(File incPath, String searchArgument, boolean findDirectory);
private static PathCriteria parsePath(File path);
private Path tempDir;
private static final FileAttribute fileAttribute;
}
class PathResolverTest {
private Path tempDir;
private static final FileAttribute fileAttribute;
@Test
public void testSearchFiles() throws IOException {
|
File child1 = new File(tempDir + Config.getPathSeparator()+"child1");
File child2 = new File(tempDir + Config.getPathSeparator()+"child2");
File child11 = new File(child1 + Config.getPathSeparator()+"child11");
File child111 = new File(child11 + Config.getPathSeparator()+"child111");
File child12 = new File(child1 + Config.getPathSeparator()+"child12");
File child21 = new File(child2 + Config.getPathSeparator()+"child21");
File child22 = new File(child2 + Config.getPathSeparator()+"child22");
if(Config.isOSPOSIXCompatible()) {
Files.createDirectory(child1.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child2.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child11.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child12.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child21.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child22.toPath(), fileAttribute).toFile().deleteOnExit();
Files.createDirectory(child111.toPath(), fileAttribute).toFile().deleteOnExit();
}
else {
Files.createDirectory(child1.toPath()).toFile().deleteOnExit();
Files.createDirectory(child2.toPath()).toFile().deleteOnExit();
Files.createDirectory(child11.toPath()).toFile().deleteOnExit();
Files.createDirectory(child12.toPath()).toFile().deleteOnExit();
Files.createDirectory(child21.toPath()).toFile().deleteOnExit();
Files.createDirectory(child22.toPath()).toFile().deleteOnExit();
Files.createDirectory(child111.toPath()).toFile().deleteOnExit();
}
ArrayList<File> expected = new ArrayList<>();
expected.add(child11);
expected.add(child12);
//test1
List<File> actual = PathResolver.resolvePath(
new File(child1.getAbsolutePath() + Config.getPathSeparator() + "*"),
new File(Config.getPathSeparator()));
assertEquals(1, actual.size());
//for(File f : expected)
// assertTrue(actual.contains(f));
//test2
actual = PathResolver.resolvePath(
new File(child1.getAbsolutePath()+Config.getPathSeparator()+"child*"),
new File(Config.getPathSeparator()));
assertEquals(expected.size(), actual.size());
for(File f : expected)
assertTrue( actual.contains(f));
//test3
actual = PathResolver.resolvePath(
new File(tempDir.toFile().getName()+Config.getPathSeparator()+"child*"),
new File(Config.getTmpDir()));
assertEquals(expected.size(), actual.size());
assertTrue( actual.contains(child1));
assertTrue( actual.contains(child2));
//test4
actual = PathResolver.resolvePath(
new File(child1.getAbsolutePath()+Config.getPathSeparator()+"child*"+Config.getPathSeparator()+"child111"),
new File(Config.getPathSeparator()));
assertEquals(1, actual.size());
assertTrue(actual.contains(child111));
}
}
|
2280644_19
|
class NoDotNamesFilter implements ResourceFilter {
@Override
public boolean accept(Resource pathname) {
return !pathname.getName().startsWith(Character.toString(AeshConstants.DOT));
}
private Resource resource;
}
class NoDotNamesFilterTest {
private Resource resource;
@Test
public void testNoDotNamesFilter() {
|
NoDotNamesFilter noDotNamesFilter = new NoDotNamesFilter();
Assert.assertFalse(noDotNamesFilter.accept(resource));
}
}
|
2280644_20
|
class DirectoryResourceFilter implements ResourceFilter {
@Override
public boolean accept(Resource path) {
return path.isDirectory();
}
private Resource resource;
}
class DirectoryResourceFilterTest {
private Resource resource;
@Test
public void testDirectoryResourceFilter() {
|
DirectoryResourceFilter directoryResourceFilter = new DirectoryResourceFilter();
Assert.assertTrue(directoryResourceFilter.accept(resource));
}
}
|
2280644_21
|
class LeafResourceFilter implements ResourceFilter {
@Override
public boolean accept(Resource path) {
return path.isLeaf();
}
private Resource resource;
}
class LeafResourceFilterTest {
private Resource resource;
@Test
public void testLeafResourceFilter() {
|
LeafResourceFilter leafResourceFilter = new LeafResourceFilter();
Assert.assertFalse(leafResourceFilter.accept(resource));
}
}
|
2280644_23
|
class ExportManager {
public String addVariable(String line) {
Matcher variableMatcher = exportPattern.matcher(line);
if (variableMatcher.matches()) {
String name = variableMatcher.group(2);
String value = variableMatcher.group(3);
if (value.contains(String.valueOf(DOLLAR + name))) {
value = value.replace(String.valueOf(DOLLAR + name), variables.get(name));
}
variables.put(name, value);
if(listener != null)
listener.exportChange(name, value);
return null;
}
return "export: usage: export [name[=value] ...]";
}
public ExportManager(File exportFile);
public ExportManager(File exportFile, ExportChangeListener listener);
public ExportManager(File exportFile, boolean exportUsesSystemEnvironment);
public ExportManager(File exportFile, boolean exportUsesSystemEnvironment, ExportChangeListener listener);
private void readVariablesFromFile();
public Set<String> keys();
public String getValue(String key);
private String getVariable(String key);
private boolean containsKey(String key);
public String getValueIgnoreCase(String name);
private String parseValue(String value);
public String listAllVariables();
public void persistVariables();
public List<String> getAllNamesWithEquals();
public List<String> getAllNames();
public List<String> findAllMatchingKeys(String word);
}
class ExportManagerTest {
@Test
public void testAddVariable() throws IOException {
|
ExportManager exportManager =
new ExportManager(new File(Config.getTmpDir()+Config.getPathSeparator()+"aesh_variable_test"));
exportManager.addVariable("export TEST=/foo/bar");
assertEquals("/foo/bar", exportManager.getValue("TEST"));
exportManager.addVariable("export FOO=/opt");
exportManager.addVariable("export FOO2=$FOO");
assertEquals("/opt", exportManager.getValue("$FOO"));
assertEquals("/opt", exportManager.getValue("${FOO}"));
assertEquals("/opt", exportManager.getValue("FOO2"));
assertEquals("/opt", exportManager.getValue("${FOO2}"));
assertEquals("/opt:/foo/bar", exportManager.getValue("$FOO:$TEST"));
assertEquals("/opt:/foo/bar", exportManager.getValue("$FOO2:${TEST}"));
assertEquals("/opt:/foo/bar:/foo", exportManager.getValue("$FOO2:$TEST:/foo"));
assertEquals("", exportManager.getValue("$FOO3"));
exportManager.addVariable("export PATH=$FOO2:$TEST:/foo");
exportManager.addVariable("export PATH=$PATH:/bar");
assertEquals("/opt:/foo/bar:/foo:/bar", exportManager.getValue("$PATH"));
exportManager.addVariable("export FOO2=/bin");
assertEquals("/bin", exportManager.getValue("${FOO2}"));
assertEquals("/bin:/foo/bar:/foo:/bar", exportManager.getValue("$PATH"));
exportManager.addVariable("export TEST=/bla /ha");
assertEquals("/bla", exportManager.getValue("TEST"));
assertEquals("ls -la /bla", exportManager.getValue("ls -la $TEST"));
assertEquals("/bla ls -la /bla", exportManager.getValue("$TEST ls -la $TEST"));
}
}
|
2280644_24
|
class ExportManager {
public String getValue(String key) {
if (key.indexOf(DOLLAR) == -1) {
String value = getVariable(key);
if (value == null)
return null;
if (value.indexOf(DOLLAR) == -1)
return value;
else
return parseValue(value);
}
return parseValue(key);
}
public ExportManager(File exportFile);
public ExportManager(File exportFile, ExportChangeListener listener);
public ExportManager(File exportFile, boolean exportUsesSystemEnvironment);
public ExportManager(File exportFile, boolean exportUsesSystemEnvironment, ExportChangeListener listener);
private void readVariablesFromFile();
public Set<String> keys();
public String addVariable(String line);
private String getVariable(String key);
private boolean containsKey(String key);
public String getValueIgnoreCase(String name);
private String parseValue(String value);
public String listAllVariables();
public void persistVariables();
public List<String> getAllNamesWithEquals();
public List<String> getAllNames();
public List<String> findAllMatchingKeys(String word);
}
class ExportManagerTest {
@Test
public void testVariableNotExist() {
|
ExportManager exportManager =
new ExportManager(new File(Config.getTmpDir()+Config.getPathSeparator()+"aesh_variable_test"));
assertEquals("", exportManager.getValue("$FOO3"));
assertEquals(null, exportManager.getValue("FOO3"));
}
}
|
2280644_25
|
class ExportManager {
public String getValue(String key) {
if (key.indexOf(DOLLAR) == -1) {
String value = getVariable(key);
if (value == null)
return null;
if (value.indexOf(DOLLAR) == -1)
return value;
else
return parseValue(value);
}
return parseValue(key);
}
public ExportManager(File exportFile);
public ExportManager(File exportFile, ExportChangeListener listener);
public ExportManager(File exportFile, boolean exportUsesSystemEnvironment);
public ExportManager(File exportFile, boolean exportUsesSystemEnvironment, ExportChangeListener listener);
private void readVariablesFromFile();
public Set<String> keys();
public String addVariable(String line);
private String getVariable(String key);
private boolean containsKey(String key);
public String getValueIgnoreCase(String name);
private String parseValue(String value);
public String listAllVariables();
public void persistVariables();
public List<String> getAllNamesWithEquals();
public List<String> getAllNames();
public List<String> findAllMatchingKeys(String word);
}
class ExportManagerTest {
@Test
public void testLoadSystemEnv() throws IOException {
|
ExportManager exportManager =
new ExportManager(new File(Config.getTmpDir()+Config.getPathSeparator()+"aesh_variable_test"), true);
String result = exportManager.getValue("PATH");
if (Config.isOSPOSIXCompatible()) {
assertTrue(result.contains("/usr"));
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.