method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
RegularPriceCategory extends PriceCategory { @Override public double getCharge(int daysRented) { double result = 0; if (daysRented > 0) { result = 2; } if (daysRented > 2) { result = 2 + (daysRented - 2) * 1.5; } return result; } private RegularPriceCategory(); int getId(); @Override double getCharge(int daysRented); @Override String toString(); static RegularPriceCategory getInstance(); }### Answer:
@Test public void testGetCharge() { assertEquals(0.0d, rpc.getCharge(-3), tolerance); assertEquals(0.0d, rpc.getCharge(0), tolerance); assertEquals(2.0d, rpc.getCharge(1), tolerance); assertEquals(2.0d, rpc.getCharge(2), tolerance); assertEquals(3.5d, rpc.getCharge(3), tolerance); assertEquals(5.0d, rpc.getCharge(4), tolerance); assertEquals(32.0d, rpc.getCharge(22), tolerance); } |
### Question:
RegularPriceCategory extends PriceCategory { @Override public String toString() { return "Regular"; } private RegularPriceCategory(); int getId(); @Override double getCharge(int daysRented); @Override String toString(); static RegularPriceCategory getInstance(); }### Answer:
@Test public void testToString() { assertEquals("Regular", rpc.toString()); } |
### Question:
Movie { @Override public int hashCode() { final int prime = 31; int result = prime + id; result = prime * result + ((releaseDate == null) ? 0 : releaseDate.hashCode()); result = prime * result + ((title == null) ? 0 : title.hashCode()); return result; } protected Movie(); Movie(String aTitle, PriceCategory aPriceCategory); Movie(String aTitle, Date aReleaseDate, PriceCategory aPriceCategory); PriceCategory getPriceCategory(); void setPriceCategory(PriceCategory aPriceCategory); String getTitle(); void setTitle(String aTitle); Date getReleaseDate(); void setReleaseDate(Date aReleaseDate); boolean isRented(); void setRented(boolean isRented); int getId(); void setId(int anId); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testHashCode() throws InterruptedException { Date d = new Date(Calendar.getInstance().getTimeInMillis()); PriceCategory pc = RegularPriceCategory.getInstance(); Movie x = new Movie(); Movie y = new Movie("A", d, pc); Movie z = new Movie("A", d, pc); int h = x.hashCode(); assertEquals(h, x.hashCode()); h = y.hashCode(); assertEquals(h, y.hashCode()); h = y.hashCode(); assertEquals(h, z.hashCode()); z.setRented(true); assertEquals(h, z.hashCode()); z = new Movie("A", d, pc); z.setPriceCategory(ChildrenPriceCategory.getInstance()); assertEquals(h, z.hashCode()); z = new Movie("B", d, pc); assertFalse(h == z.hashCode()); Thread.sleep(10); z = new Movie("A", new Date(Calendar.getInstance().getTimeInMillis()), pc); assertFalse(h == z.hashCode()); z = new Movie("A", d, pc); z.setId(42); assertFalse(h == z.hashCode()); } |
### Question:
Movie { protected Movie() { } protected Movie(); Movie(String aTitle, PriceCategory aPriceCategory); Movie(String aTitle, Date aReleaseDate, PriceCategory aPriceCategory); PriceCategory getPriceCategory(); void setPriceCategory(PriceCategory aPriceCategory); String getTitle(); void setTitle(String aTitle); Date getReleaseDate(); void setReleaseDate(Date aReleaseDate); boolean isRented(); void setRented(boolean isRented); int getId(); void setId(int anId); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testMovie() { Movie m = new Movie(); assertNull(m.getPriceCategory()); assertNull(m.getReleaseDate()); assertNull(m.getTitle()); assertFalse(m.isRented()); } |
### Question:
Movie { public void setTitle(String aTitle) { if (this.title != null) { throw new IllegalStateException(); } this.title = aTitle; } protected Movie(); Movie(String aTitle, PriceCategory aPriceCategory); Movie(String aTitle, Date aReleaseDate, PriceCategory aPriceCategory); PriceCategory getPriceCategory(); void setPriceCategory(PriceCategory aPriceCategory); String getTitle(); void setTitle(String aTitle); Date getReleaseDate(); void setReleaseDate(Date aReleaseDate); boolean isRented(); void setRented(boolean isRented); int getId(); void setId(int anId); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test(expected = IllegalStateException.class) public void testSetTitle() { Movie m = new Movie(); m.setTitle("Hallo"); assertEquals("Hallo", m.getTitle()); m.setTitle(null); } |
### Question:
Movie { public void setReleaseDate(Date aReleaseDate) { if (this.releaseDate != null) { throw new IllegalStateException(); } this.releaseDate = aReleaseDate; } protected Movie(); Movie(String aTitle, PriceCategory aPriceCategory); Movie(String aTitle, Date aReleaseDate, PriceCategory aPriceCategory); PriceCategory getPriceCategory(); void setPriceCategory(PriceCategory aPriceCategory); String getTitle(); void setTitle(String aTitle); Date getReleaseDate(); void setReleaseDate(Date aReleaseDate); boolean isRented(); void setRented(boolean isRented); int getId(); void setId(int anId); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test(expected = IllegalStateException.class) public void testSetReleaseDate() { Movie m = new Movie(); Date d = new Date(Calendar.getInstance().getTimeInMillis()); m.setReleaseDate(d); assertEquals(d, m.getReleaseDate()); m.setReleaseDate(null); } |
### Question:
ChildrenPriceCategory extends PriceCategory { @Override public double getCharge(int daysRented) { double result = 0; if (daysRented > 0) { result = 1.5; if (daysRented > 3) { result += (daysRented - 3) * 1.5; } } return result; } private ChildrenPriceCategory(); int getId(); @Override double getCharge(int daysRented); @Override String toString(); static ChildrenPriceCategory getInstance(); }### Answer:
@Test public void testGetCharge() { assertEquals(0.0D, cpc.getCharge(-5), 1.0e-10); assertEquals(0.0, cpc.getCharge(0), 1.0e-10); assertEquals(1.5D, cpc.getCharge(1), 1.0e-10); assertEquals(1.5D, cpc.getCharge(2), 1.0e-10); assertEquals(1.5D, cpc.getCharge(3), 1.0e-10); assertEquals(3.0D, cpc.getCharge(4), 1.0e-10); assertEquals(151.5D, cpc.getCharge(103), 1.0e-10); } |
### Question:
ChildrenPriceCategory extends PriceCategory { @Override public String toString() { return "Children"; } private ChildrenPriceCategory(); int getId(); @Override double getCharge(int daysRented); @Override String toString(); static ChildrenPriceCategory getInstance(); }### Answer:
@Test public void testToString() { assertEquals("Children", cpc.toString()); } |
### Question:
PriceCategory { public int getFrequentRenterPoints(int daysRented) { return daysRented > 0 ? 1 : 0; } int getId(); abstract double getCharge(int daysRented); int getFrequentRenterPoints(int daysRented); }### Answer:
@Test public void testGetFrequentRenterPoints() { assertEquals(0, pc.getFrequentRenterPoints(-6)); assertEquals(0, pc.getFrequentRenterPoints(0)); assertEquals(1, pc.getFrequentRenterPoints(1)); assertEquals(1, pc.getFrequentRenterPoints(2)); assertEquals(1, pc.getFrequentRenterPoints(4000)); } |
### Question:
Part04HandlingErrors { public Flux<Integer> errorIsTerminal(Flux<String> numbers) { return numbers.map(s -> Integer.parseInt(s)).log(); } Flux<Integer> errorIsTerminal(Flux<String> numbers); Flux<Integer> handleErrorWithFallback(Flux<String> numbers); Flux<Integer> handleErrorAndContinue(Flux<String> numbers); Flux<Integer> handleErrorWithEmptyMonoAndContinue(Flux<String> numbers); Flux<String> timeOutWithRetry(Flux<String> colors); Mono<String> simulateRemoteCall(String input); }### Answer:
@Test public void errorIsTerminal() { Flux<String> flux = Flux.just("31", "12", "2", "A", "5", "6"); Flux<Integer> numbers = workshop.errorIsTerminal(flux); StepVerifier.create(numbers).expectNext(31, 12, 2).expectError().verify(); } |
### Question:
Part04HandlingErrors { public Flux<Integer> handleErrorWithFallback(Flux<String> numbers) { return numbers.map(s -> Integer.parseInt(s)) .onErrorReturn(NumberFormatException.class, 0) .log(); } Flux<Integer> errorIsTerminal(Flux<String> numbers); Flux<Integer> handleErrorWithFallback(Flux<String> numbers); Flux<Integer> handleErrorAndContinue(Flux<String> numbers); Flux<Integer> handleErrorWithEmptyMonoAndContinue(Flux<String> numbers); Flux<String> timeOutWithRetry(Flux<String> colors); Mono<String> simulateRemoteCall(String input); }### Answer:
@Test public void handleErrorWithFallback() { Flux<String> flux = Flux.just("31", "12", "2", "A", "5", "6"); Flux<Integer> numbers = workshop.handleErrorWithFallback(flux); StepVerifier.create(numbers).expectNext(31, 12, 2, 0).expectComplete().verify(); } |
### Question:
Part04HandlingErrors { public Flux<Integer> handleErrorAndContinue(Flux<String> numbers) { return numbers.flatMap(s -> Mono.just(s).map(Integer::parseInt) .onErrorReturn(NumberFormatException.class, 0).log()); } Flux<Integer> errorIsTerminal(Flux<String> numbers); Flux<Integer> handleErrorWithFallback(Flux<String> numbers); Flux<Integer> handleErrorAndContinue(Flux<String> numbers); Flux<Integer> handleErrorWithEmptyMonoAndContinue(Flux<String> numbers); Flux<String> timeOutWithRetry(Flux<String> colors); Mono<String> simulateRemoteCall(String input); }### Answer:
@Test public void handleErrorAndContinue() { Flux<String> flux = Flux.just("31", "12", "2", "A", "5", "6"); Flux<Integer> numbers = workshop.handleErrorAndContinue(flux); StepVerifier.create(numbers).expectNext(31, 12, 2, 0, 5, 6).expectComplete().verify(); } |
### Question:
Part04HandlingErrors { public Flux<Integer> handleErrorWithEmptyMonoAndContinue(Flux<String> numbers) { return numbers.flatMap(s -> Mono.just(s).map(Integer::parseInt) .onErrorResume(throwable -> Mono.empty())).log(); } Flux<Integer> errorIsTerminal(Flux<String> numbers); Flux<Integer> handleErrorWithFallback(Flux<String> numbers); Flux<Integer> handleErrorAndContinue(Flux<String> numbers); Flux<Integer> handleErrorWithEmptyMonoAndContinue(Flux<String> numbers); Flux<String> timeOutWithRetry(Flux<String> colors); Mono<String> simulateRemoteCall(String input); }### Answer:
@Test public void handleErrorWithEmptyMonoAndContinue() { Flux<String> flux = Flux.just("31", "12", "2", "A", "5", "6"); Flux<Integer> numbers = workshop.handleErrorWithEmptyMonoAndContinue(flux); StepVerifier.create(numbers).expectNext(31, 12, 2, 5, 6).expectComplete().verify(); } |
### Question:
Part04HandlingErrors { public Flux<String> timeOutWithRetry(Flux<String> colors) { return colors.concatMap(color -> simulateRemoteCall(color) .timeout(Duration.ofMillis(400)) .doOnError(s -> log.info(s.getMessage())) .retry(2).onErrorReturn("default")).log(); } Flux<Integer> errorIsTerminal(Flux<String> numbers); Flux<Integer> handleErrorWithFallback(Flux<String> numbers); Flux<Integer> handleErrorAndContinue(Flux<String> numbers); Flux<Integer> handleErrorWithEmptyMonoAndContinue(Flux<String> numbers); Flux<String> timeOutWithRetry(Flux<String> colors); Mono<String> simulateRemoteCall(String input); }### Answer:
@Test public void timeOutWithRetry() { Flux<String> colors = Flux.just("red", "black", "tan"); Flux<String> results = workshop.timeOutWithRetry(colors); StepVerifier.create(results).expectNext("processed red", "default", "processed tan").verifyComplete(); } |
### Question:
Part05Subscribe { public Flux<Integer> subscribeEmpty() { Flux<Integer> flux = Flux.just(1, 2, 3); flux.log().subscribe(); return flux; } Flux<Integer> subscribeEmpty(); Flux<Integer> subscribeWithConsumer(); Flux<Integer> subscribeWithConsumerAndCompleteConsumer(); Flux<Integer> subscribeWithConsumerAndErrorConsumer(); Flux<Integer> subscribeWithSubscriptionConsumer(); Flux<Integer> subscribeWithSubscription(); }### Answer:
@Test public void subscribeEmpty() { Flux<Integer> flux = workshop.subscribeEmpty(); StepVerifier.create(flux) .expectNext(1, 2, 3).verifyComplete(); } |
### Question:
Part05Subscribe { public Flux<Integer> subscribeWithConsumer() { Flux<Integer> flux = Flux.just(1, 2, 3); flux.log().subscribe(integer -> log.info("{}", integer)); return flux; } Flux<Integer> subscribeEmpty(); Flux<Integer> subscribeWithConsumer(); Flux<Integer> subscribeWithConsumerAndCompleteConsumer(); Flux<Integer> subscribeWithConsumerAndErrorConsumer(); Flux<Integer> subscribeWithSubscriptionConsumer(); Flux<Integer> subscribeWithSubscription(); }### Answer:
@Test public void subscribeWithConsumer() { Flux<Integer> flux = workshop.subscribeWithConsumer(); StepVerifier.create(flux) .expectNext(1, 2, 3).verifyComplete(); } |
### Question:
Part05Subscribe { public Flux<Integer> subscribeWithConsumerAndCompleteConsumer() { Flux<Integer> flux = Flux.just(1, 2, 3); flux.subscribe(integer -> log.info("{}", integer), null, () -> log.info("completed")); return flux; } Flux<Integer> subscribeEmpty(); Flux<Integer> subscribeWithConsumer(); Flux<Integer> subscribeWithConsumerAndCompleteConsumer(); Flux<Integer> subscribeWithConsumerAndErrorConsumer(); Flux<Integer> subscribeWithSubscriptionConsumer(); Flux<Integer> subscribeWithSubscription(); }### Answer:
@Test public void subscribeWithConsumerAndCompleteConsumer() { Flux<Integer> flux = workshop.subscribeWithConsumerAndCompleteConsumer(); StepVerifier.create(flux) .expectNext(1, 2, 3).verifyComplete(); } |
### Question:
Part05Subscribe { public Flux<Integer> subscribeWithConsumerAndErrorConsumer() { Flux<Integer> flux = Flux.just(1, 2, 3, 4).map(i -> { if (i != 4) { return i; } else { throw new IllegalStateException("error"); } }); flux.log().subscribe(integer -> log.info("{}", integer), throwable -> log.info("{}", throwable.getMessage())); return flux; } Flux<Integer> subscribeEmpty(); Flux<Integer> subscribeWithConsumer(); Flux<Integer> subscribeWithConsumerAndCompleteConsumer(); Flux<Integer> subscribeWithConsumerAndErrorConsumer(); Flux<Integer> subscribeWithSubscriptionConsumer(); Flux<Integer> subscribeWithSubscription(); }### Answer:
@Test public void subscribeWithConsumerAndErrorConsumer() { Flux<Integer> flux = workshop.subscribeWithConsumerAndErrorConsumer(); StepVerifier.create(flux) .expectNext(1, 2, 3).verifyError(); } |
### Question:
Part05Subscribe { public Flux<Integer> subscribeWithSubscriptionConsumer() { Flux<Integer> flux = Flux.just(1, 2, 3); flux.log().subscribe(null, null, null, new Consumer<Subscription>() { @Override public void accept(Subscription subscription) { subscription.request(2); } }); return flux; } Flux<Integer> subscribeEmpty(); Flux<Integer> subscribeWithConsumer(); Flux<Integer> subscribeWithConsumerAndCompleteConsumer(); Flux<Integer> subscribeWithConsumerAndErrorConsumer(); Flux<Integer> subscribeWithSubscriptionConsumer(); Flux<Integer> subscribeWithSubscription(); }### Answer:
@Test public void subscribeWithSubscriptionConsumer() { Flux<Integer> flux = workshop.subscribeWithSubscriptionConsumer(); StepVerifier.create(flux) .expectNext(1, 2, 3).verifyComplete(); } |
### Question:
Part05Subscribe { public Flux<Integer> subscribeWithSubscription() { Flux<Integer> flux = Flux.just(1, 2, 3); flux.log().subscribe(new Subscriber<Integer>() { Subscription s; @Override public void onSubscribe(Subscription s) { this.s = s; s.request(1); } @Override public void onNext(Integer integer) { s.request(integer); } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }); return flux; } Flux<Integer> subscribeEmpty(); Flux<Integer> subscribeWithConsumer(); Flux<Integer> subscribeWithConsumerAndCompleteConsumer(); Flux<Integer> subscribeWithConsumerAndErrorConsumer(); Flux<Integer> subscribeWithSubscriptionConsumer(); Flux<Integer> subscribeWithSubscription(); }### Answer:
@Test public void subscribeWithSubscription() { Flux<Integer> flux = workshop.subscribeWithSubscription(); StepVerifier.create(flux) .expectNext(1, 2, 3).verifyComplete(); } |
### Question:
Part02Transform { Flux<Integer> transformToLength(Flux<String> flux) { return flux.map(s -> s.length()); } Flux<Tuple2<String, Integer>> pairValues(Flux<String> flux1, Flux<Integer> flux2); Mono<Order> combineValues(Mono<String> phoneNumber, Mono<String> deliveryAddress); }### Answer:
@Test public void transform() { Flux<Integer> flux = workshop.transformToLength(Flux.just("foo", "bar")); StepVerifier.create(flux).expectNext(3, 3).verifyComplete(); } |
### Question:
Part02Transform { Flux<String> characters(Flux<String> flux) { return flux .map(s -> s.toUpperCase()) .flatMap(s -> Flux.fromArray(s.split("")).log()); } Flux<Tuple2<String, Integer>> pairValues(Flux<String> flux1, Flux<Integer> flux2); Mono<Order> combineValues(Mono<String> phoneNumber, Mono<String> deliveryAddress); }### Answer:
@Test public void characters() { Flux<String> flux = workshop.characters(Flux.just("foo", "bar")); StepVerifier.create(flux).expectNextCount(6).verifyComplete(); } |
### Question:
Part02Transform { Flux<String> combineInEmissionOrder(Flux<String> flux1, Flux<String> flux2) { return Flux.merge(flux1, flux2); } Flux<Tuple2<String, Integer>> pairValues(Flux<String> flux1, Flux<Integer> flux2); Mono<Order> combineValues(Mono<String> phoneNumber, Mono<String> deliveryAddress); }### Answer:
@Test public void combineInEmissionOrder() { Flux<String> flux1 = Flux.just("foo", "bar").delayElements(Duration.ofMillis(1)); Flux<String> flux2 = Flux.just("a", "b", "c").delayElements(Duration.ofMillis(1)); StepVerifier.create(workshop.combineInEmissionOrder(flux1, flux2)).expectNextCount(5).verifyComplete(); } |
### Question:
Part02Transform { public Flux<Tuple2<String, Integer>> pairValues(Flux<String> flux1, Flux<Integer> flux2) { return Flux.zip(flux1, flux2); } Flux<Tuple2<String, Integer>> pairValues(Flux<String> flux1, Flux<Integer> flux2); Mono<Order> combineValues(Mono<String> phoneNumber, Mono<String> deliveryAddress); }### Answer:
@Test public void pairValues() { Flux<String> flux1 = Flux.just("a", "b", "c"); Flux<Integer> flux2 = Flux.just(1, 2, 3, 4); StepVerifier.create(workshop.pairValues(flux1, flux2)) .assertNext(tuple2 -> { assertThat(tuple2.getT1()).isEqualTo("a"); assertThat(tuple2.getT2()).isEqualTo(1); }) .assertNext(tuple2 -> { assertThat(tuple2.getT1()).isEqualTo("b"); assertThat(tuple2.getT2()).isEqualTo(2); }) .assertNext(tuple2 -> { assertThat(tuple2.getT1()).isEqualTo("c"); assertThat(tuple2.getT2()).isEqualTo(3); }) .verifyComplete(); } |
### Question:
PRNGSeedFactoryBean implements FactoryBean<Integer> { @Override public Integer getObject() { try { int time = new java.util.Date().hashCode(); int ipAddress = InetAddress.getLocalHost().hashCode(); int rand = metaPrng.nextInt(); int seed = (ipAddress & 0xffff) | ((time & 0x00ff) << 32) | (rand & 0x0f000000); logger.info("seed = " + seed); return seed; } catch (UnknownHostException e) { throw new RuntimeException(e); } } @Override Integer getObject(); @Override Class<?> getObjectType(); @Override boolean isSingleton(); }### Answer:
@Test public void test() { for(int i=0; i<10; i++) { Integer result = bean.getObject(); System.out.println(result); } } |
### Question:
RationalNumber { public void optimize() { int gcd = calcGcd(numerator, denominator); this.numerator = this.numerator / gcd; this.denominator = this.denominator / gcd; } RationalNumber(int numerator, int denominator); static RationalNumber create(int numerator, int denominator); int getNumerator(); int getDenominator(); void optimize(); String toString(); boolean equals(Object obj); int hashCode(); }### Answer:
@Test public void optimizeTest() throws Exception { RationalNumber actual = RationalNumber.create(15, 9); actual.optimize(); RationalNumber expected = RationalNumber.create(5, 3); Assert.assertEquals(expected, actual); } |
### Question:
RationalNumber { public static RationalNumber create(int numerator, int denominator) { return new RationalNumber(numerator, denominator); } RationalNumber(int numerator, int denominator); static RationalNumber create(int numerator, int denominator); int getNumerator(); int getDenominator(); void optimize(); String toString(); boolean equals(Object obj); int hashCode(); }### Answer:
@Test public void createTest() throws Exception { RationalNumber actual = RationalNumber.create(15, 9); RationalNumber expected = new RationalNumber(15, 9); Assert.assertEquals(expected, actual); }
@Test(expected = ArithmeticException.class) public void createTestOnBadData() throws Exception { RationalNumber.create(15, 0); } |
### Question:
HumansJdbcTemplateDaoImpl implements HumansDao { @Override public Human find(int id) { try { return template.queryForObject(SQL_SELECT_USER_BY_ID, humanRowMapper, id); } catch (EmptyResultDataAccessException e) { throw new IllegalArgumentException("User with id <" + id + "> not found"); } } HumansJdbcTemplateDaoImpl(DataSource dataSource); @Override List<Human> findAllByAge(int age); @Override void save(Human model); @Override Human find(int id); @Override void update(Human model); @Override void delete(int id); @Override List<Human> findAll(); }### Answer:
@Test public void findTest() throws Exception { Human expected = Human.builder() .id(2) .age(19) .name("Андрей") .citizen("Россия") .build(); Human actual = testedHumansDao.find(2); Assert.assertEquals(expected, actual); }
@Test(expected = IllegalArgumentException.class) public void findTestOnBadUserId() { testedHumansDao.find(44); } |
### Question:
Validator { @VisibleForTesting void validateExactlyOnceSelect(SqlNodeList query) { Preconditions.checkArgument(query.size() > 0); SqlNode last = query.get(query.size() - 1); long n = StreamSupport.stream(query.spliterator(), false) .filter(x -> x instanceof SqlSelect) .count(); Preconditions.checkArgument(n == 1 && last instanceof SqlSelect, "Only one top-level SELECT statement is allowed"); statement = (SqlSelect) last; } }### Answer:
@Test(expected = IllegalArgumentException.class) public void testMultiSqlInsert() throws IOException, ParseException { String sql = Joiner.on(";\n").join( "INSERT INTO foo (SELECT * FROM bar)", "INSERT INTO foo (SELECT * FROM bar)" ); SqlNodeList nodes = Planner.parse(sql); Validator validator = new Validator(); validator.validateExactlyOnceSelect(nodes); }
@Test public void testWrapSelectIntoInsert() throws IOException, ParseException { String sql = Joiner.on(";\n").join( "SET foo = 1", "SELECT * FROM bar" ); SqlNodeList nodes = Planner.parse(sql); Validator validator = new Validator(); validator.validateExactlyOnceSelect(nodes); } |
### Question:
JobWatcherUtil { static HealthCheckReport computeHealthCheckReport(Map<UUID, JobDefinition> jobs, Map<UUID, InstanceInfo> instances) { JobWatcherUtil.StateView v = JobWatcherUtil.computeState(jobs, instances); HealthCheckReport res = new HealthCheckReport(); for (Map.Entry<UUID, List<InstanceInfo>> e : v.jobInstances.entrySet()) { JobDefinition job = v.jobs.get(e.getKey()); if (job == null) { res.spuriousInstances().addAll(e.getValue()); continue; } Map<InstanceInfo, JobDefinitionDesiredstate> instanceState = new HashMap<>(); e.getValue().forEach(x -> instanceState.put(x, JobWatcherUtil.computeActualState(x))); List<JobDefinitionDesiredstate> desiredState = new ArrayList<>(job.getDesiredState()); List<InstanceInfo> healthyInstances = new ArrayList<>(); for (Map.Entry<InstanceInfo, JobDefinitionDesiredstate> entry : instanceState.entrySet()) { if (desiredState.contains(entry.getValue())) { desiredState.remove(entry.getValue()); healthyInstances.add(entry.getKey()); } } List<InstanceInfo> allInstances = e.getValue(); allInstances.removeAll(healthyInstances); res.instancesWithDifferentParameters().addAll(allInstances); if (!desiredState.isEmpty()) { res.instancesToStart().put( new ExtendedJobDefinition().uuid(e.getKey()) .definition(job), desiredState); } } return res; } private JobWatcherUtil(); }### Answer:
@Test public void testMismatchedParameter() { UUID instId = UUID.randomUUID(); UUID jobId = UUID.randomUUID(); InstanceInfo instance = mockInstanceInfo("foo", 1, 4096, jobId, InstanceStatus.StateEnum.RUNNING); JobDefinition job = mockJobWithSingleInstance("foo", 1, 2048); HealthCheckReport report = JobWatcherUtil.computeHealthCheckReport( Collections.singletonMap(jobId, job), Collections.singletonMap(instId, instance)); assertTrue(report.spuriousInstances().isEmpty()); assertEquals(1, report.instancesWithDifferentParameters().size()); assertEquals(1, report.instancesToStart().size()); }
@Test public void testStartJob() { UUID jobId = UUID.randomUUID(); JobDefinition job = mockJobWithSingleInstance("foo", 1, 2048); HealthCheckReport report = JobWatcherUtil.computeHealthCheckReport( Collections.singletonMap(jobId, job), Collections.emptyMap()); assertTrue(report.spuriousInstances().isEmpty()); assertTrue(report.instancesWithDifferentParameters().isEmpty()); assertEquals(1, report.instancesToStart().size()); }
@Test public void testKillingSpuriousInstances() { UUID instId = UUID.randomUUID(); UUID jobId = UUID.randomUUID(); InstanceInfo instance = mockInstanceInfo("foo", 1, 4096, jobId, InstanceStatus.StateEnum.ACCEPTED); HealthCheckReport report = JobWatcherUtil.computeHealthCheckReport( Collections.emptyMap(), Collections.singletonMap(instId, instance)); assertEquals(1, report.spuriousInstances().size()); instance = mockInstanceInfo("foo", 1, 4096, jobId, InstanceStatus.StateEnum.KILLED); report = JobWatcherUtil.computeHealthCheckReport( Collections.emptyMap(), Collections.singletonMap(instId, instance)); assertTrue(report.spuriousInstances().isEmpty()); }
@Test public void testHealthyInstance() { UUID instId = UUID.randomUUID(); UUID jobId = UUID.randomUUID(); InstanceInfo instance = mockInstanceInfo("foo", 1, 4096, jobId, InstanceStatus.StateEnum.RUNNING); JobDefinition job = mockJobWithSingleInstance("foo", 1, 4096); HealthCheckReport report = JobWatcherUtil.computeHealthCheckReport( Collections.singletonMap(jobId, job), Collections.singletonMap(instId, instance)); assertTrue(report.spuriousInstances().isEmpty()); assertTrue(report.instancesWithDifferentParameters().isEmpty()); assertTrue(report.instancesToStart().isEmpty()); } |
### Question:
JobDeployer { void start(JobGraph job, JobConf desc) throws Exception { AthenaXYarnClusterDescriptor descriptor = new AthenaXYarnClusterDescriptor(clusterConf, yarnClient, flinkConf, desc); start(descriptor, job); } JobDeployer(YarnClusterConfiguration clusterConf, YarnClient yarnClient,
ScheduledExecutorService executor, Configuration flinkConf); }### Answer:
@Test public void testDeployerWithIsolatedConfiguration() throws Exception { YarnClusterConfiguration clusterConf = mock(YarnClusterConfiguration.class); doReturn(new YarnConfiguration()).when(clusterConf).conf(); ScheduledExecutorService executor = mock(ScheduledExecutorService.class); Configuration flinkConf = new Configuration(); YarnClient client = mock(YarnClient.class); JobDeployer deploy = new JobDeployer(clusterConf, client, executor, flinkConf); AthenaXYarnClusterDescriptor desc = mock(AthenaXYarnClusterDescriptor.class); YarnClusterClient clusterClient = mock(YarnClusterClient.class); doReturn(clusterClient).when(desc).deploy(); ActorGateway actorGateway = mock(ActorGateway.class); doReturn(actorGateway).when(clusterClient).getJobManagerGateway(); doReturn(Future$.MODULE$.successful(null)).when(actorGateway).ask(any(), any()); JobGraph jobGraph = mock(JobGraph.class); doReturn(JobID.generate()).when(jobGraph).getJobID(); deploy.start(desc, jobGraph); verify(clusterClient).runDetached(jobGraph, null); } |
### Question:
InstanceManager implements AutoCloseable { public void changeState(UUID uuid, InstanceState desiredState) throws IOException, YarnException { if (desiredState == null || desiredState.getState() != InstanceState.StateEnum.KILLED) { throw new UnsupportedOperationException(); } InstanceInfo info = instances().get(uuid); if (info == null) { return; } ClusterInfo cluster = clusters.get(info.clusterName()); Preconditions.checkNotNull(cluster); cluster.client().killApplication(info.appId()); } @VisibleForTesting InstanceManager(
Map<String, ClusterInfo> clusters,
InstanceStateUpdateListener listener,
ScheduledExecutorService executor,
long rescanInterval); @VisibleForTesting static InstanceManager create(
AthenaXConfiguration conf,
InstanceStateUpdateListener listener,
ScheduledExecutorService executor); InstanceStatus getInstanceStatus(UUID uuid); InstanceState getInstanceState(UUID uuid); void changeState(UUID uuid, InstanceState desiredState); ConcurrentHashMap<UUID, InstanceInfo> instances(); void start(); @Override void close(); void killYarnApplication(String clusterName, ApplicationId appId); Map.Entry<UUID, ApplicationId> instantiate(
JobDefinitionDesiredstate state,
UUID jobUUID,
JobCompilationResult job); }### Answer:
@Test public void testChangeState() throws Exception { YarnClient client = mock(YarnClient.class); YarnClusterConfiguration conf = mock(YarnClusterConfiguration.class); ClusterInfo clusterInfo = new ClusterInfo("foo", conf, client); UUID app = UUID.randomUUID(); ApplicationId yarnAppId = mock(ApplicationId.class); try (InstanceManager manager = new InstanceManager( Collections.singletonMap("foo", clusterInfo), mock(InstanceStateUpdateListener.class), mock(ScheduledExecutorService.class), AthenaXExtraConfigOptions.INSTANCE_MANAGER_RESCAN_INTERVAL.defaultValue())) { InstanceInfo instance = new InstanceInfo("foo", yarnAppId, mock(InstanceMetadata.class), mock(InstanceStatus.class)); manager.instances().put(app, instance); manager.changeState(app, new InstanceState().state(InstanceState.StateEnum.KILLED)); verify(client).killApplication(eq(yarnAppId)); } } |
### Question:
Validator { @VisibleForTesting void extract(SqlNodeList query) { for (SqlNode n : query) { if (n instanceof SqlSetOption) { extract((SqlSetOption) n); } else if (n instanceof SqlCreateFunction) { extract((SqlCreateFunction) n); } } } }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInvalidSetSystemProperties() throws IOException, ParseException { String sql = "ALTER SYSTEM SET bar = OFF"; SqlNodeList nodes = Planner.parse(sql); Validator validator = new Validator(); validator.extract(nodes); } |
### Question:
Planner { @VisibleForTesting static SqlNodeList parse(String sql) throws ParseException { try (StringReader in = new StringReader(sql)) { SqlParserImpl impl = new SqlParserImpl(in); impl.switchTo("BTID"); impl.setTabSize(1); impl.setQuotedCasing(Lex.JAVA.quotedCasing); impl.setUnquotedCasing(Lex.JAVA.unquotedCasing); impl.setIdentifierMaxLength(DEFAULT_IDENTIFIER_MAX_LENGTH); return impl.SqlStmtsEof(); } } Planner(Map<String, AthenaXTableCatalog> inputs, AthenaXTableCatalog outputs); JobCompilationResult sql(String sql, int parallelism); }### Answer:
@Test public void testCreateFunction() throws Exception { String sql = "CREATE FUNCTION foo AS 'com.uber.foo';"; Planner.parse(sql); sql = "CREATE FUNCTION foo AS 'com.uber.foo' USING JAR 'mock: Planner.parse(sql); }
@Test public void testSetOption() throws Exception { String sql = "SET flink.enable.checkpoint=1;"; Planner.parse(sql); }
@Test public void testMultipleStatement() throws Exception { String sql = "SET flink.enable.checkpoint=1;"; SqlNodeList list = Planner.parse(sql); assertEquals(1, list.size()); sql = "SET flink.enable.checkpoint=1;\n" + "SELECT * FROM foo"; list = Planner.parse(sql); assertEquals(2, list.size()); sql = "SET flink.enable.checkpoint=1;\n" + "SELECT * FROM foo;"; list = Planner.parse(sql); assertEquals(2, list.size()); } |
### Question:
KafkaUtils { static Properties getSubProperties(Map<String, String> prop, String prefix) { Properties p = new Properties(); for (Map.Entry<String, String> e : prop.entrySet()) { String key = e.getKey(); if (key.startsWith(prefix)) { p.put(key.substring(prefix.length()), e.getValue()); } } return p; } private KafkaUtils(); }### Answer:
@Test public void testGetSubProperties() { Map<String, String> parent = Collections.singletonMap("foo.bar", "1"); Properties children = KafkaUtils.getSubProperties(parent, "foo."); assertEquals(1, children.size()); assertEquals("1", children.getProperty("bar")); } |
### Question:
JobWatcherUtil { static StateView computeState(Map<UUID, JobDefinition> jobs, Map<UUID, InstanceInfo> instances) { HashMap<UUID, UUID> instanceToJob = new HashMap<>(); HashMap<UUID, List<InstanceInfo>> jobInstances = new HashMap<>(); for (Map.Entry<UUID, InstanceInfo> e : instances.entrySet()) { YarnApplicationState state = YarnApplicationState.valueOf(e.getValue().status().getState().toString()); if (!isInstanceAlive(state)) { continue; } UUID jobId = e.getValue().metadata().jobDefinition(); UUID instanceId = e.getKey(); instanceToJob.put(instanceId, jobId); if (!jobInstances.containsKey(jobId)) { jobInstances.put(jobId, new ArrayList<>()); } jobInstances.get(jobId).add(e.getValue()); } jobs.keySet().stream().filter(x -> !jobInstances.containsKey(x)) .forEach(x -> jobInstances.put(x, Collections.emptyList())); return new StateView(jobs, instances, instanceToJob, jobInstances); } private JobWatcherUtil(); }### Answer:
@Test public void testComputeState() { HashMap<UUID, JobDefinition> jobMap = new HashMap<>(); HashMap<UUID, InstanceInfo> instanceMap = new HashMap<>(); mockState1(jobMap, instanceMap); JobWatcherUtil.StateView v = JobWatcherUtil.computeState(jobMap, instanceMap); HashMap<UUID, List<InstanceInfo>> jobInstances = new HashMap<>(); HashMap<UUID, UUID> instanceToJob = new HashMap<>(); for (Map.Entry<UUID, InstanceInfo> e : instanceMap.entrySet()) { UUID jobId = e.getValue().metadata().jobDefinition(); instanceToJob.put(e.getKey(), jobId); List<InstanceInfo> li = jobInstances.getOrDefault(jobId, new ArrayList<>()); li.add(e.getValue()); jobInstances.put(jobId, li); } assertEquals(jobMap, v.jobs()); assertEquals(instanceMap, v.instances()); assertEquals(instanceToJob, v.instanceToJob()); assertEquals(jobInstances, v.jobInstances()); } |
### Question:
StatisticsQueue { public List<QueryStats> getReportSortedBy(String sortByVal) { SortBy sortBy; try { sortBy = SortBy.valueOf(sortByVal); } catch (Exception e) { throw new IllegalArgumentException("allowed values are: " + Arrays.toString(SortBy.values())); } List<QueryStats> res = new ArrayList<>(statsByQuery.values()); Collections.sort(res, sortBy.getComparator()); return res; } StatisticsQueue(boolean paused); boolean isPaused(); void stop(); void pause(boolean val); Future enqueue(final QueryExecutionEvent event); void reset(); List<QueryStats> getReportSortedBy(String sortByVal); }### Answer:
@Test public void shouldCollectAndSortStatistics() throws ExecutionException, InterruptedException { List<QueryStats> report = queue.getReportSortedBy("avg"); a(report.get(0).getQuery()).shouldBeEqual("test2"); a(report.get(0).getAvg()).shouldBeEqual(35); a(report.get(0).getTotal()).shouldBeEqual(345); a(report.get(0).getCount()).shouldBeEqual(10); a(report.get(0).getMin()).shouldBeEqual(30); a(report.get(0).getMax()).shouldBeEqual(39); a(report.get(1).getQuery()).shouldBeEqual("test1"); a(report.get(1).getAvg()).shouldBeEqual(25); a(report.get(1).getTotal()).shouldBeEqual(245); a(report.get(1).getCount()).shouldBeEqual(10); a(report.get(1).getMin()).shouldBeEqual(20); a(report.get(1).getMax()).shouldBeEqual(29); a(report.get(2).getQuery()).shouldBeEqual("test"); a(report.get(2).getAvg()).shouldBeEqual(15); a(report.get(2).getTotal()).shouldBeEqual(145); a(report.get(2).getCount()).shouldBeEqual(10); a(report.get(2).getMin()).shouldBeEqual(10); a(report.get(2).getMax()).shouldBeEqual(19); } |
### Question:
Base { public static RowProcessor find(String query, Object ... params) { return new DB(DB.DEFAULT_NAME).find(query, params); } private Base(); static DB open(); static DB open(String driver, String url, String user, String password); static DB open(String driver, String url, Properties props); static DB open(String jndiName); static DB open(String jndiName, Properties jndiProperties); static DB open(DataSource dataSource); static Connection connection(); static boolean hasConnection(); static void close(boolean suppressWarning); static void close(); static Long count(String table); static Long count(String table, String query, Object... params); static Object firstCell(String query, Object... params); static List<Map> findAll(String query, Object... params); static List firstColumn(String query, Object... params); static List<Map> findAll(String query); static RowProcessor find(String query, Object ... params); static RowProcessor find(RowProcessor.ResultSetType type, RowProcessor.ResultSetConcur concur, int fetchSize, String query, Object ... params); static void find(String sql, RowListener listener); static int exec(String query); static int exec(String query, Object ... params); static void openTransaction(); static void commitTransaction(); static void rollbackTransaction(); static PreparedStatement startBatch(String parametrizedStatement); static void addBatch(PreparedStatement ps, Object... parameters); static int[] executeBatch(PreparedStatement ps); static void closePreparedStatement(PreparedStatement ps); static void attach(Connection connection); static Connection detach(); static T withDb(String jndiName, Properties jndiProperties, Supplier<T> supplier); static T withDb(DataSource dataSource, Supplier<T> supplier); static T withDb(String jndiName, Supplier<T> supplier); static T withDb(String driver, String url, Properties properties, Supplier<T> supplier); static T withDb(String driver, String url, String user, String password, Supplier<T> supplier); static T withDb(Supplier<T> supplier); }### Answer:
@Test public void testBaseFinder() { final List<Map> records = new ArrayList<>(); Base.find("select * from people order by id", new RowListenerAdapter() { @Override public void onNext(Map record) { records.add(record); } }); the(records.get(0).get("name")).shouldBeEqual("John"); the(records.get(3).get("name")).shouldBeEqual("Joe"); }
@Test public void testFindParametrized(){ Base.find("select * from people where id > ? and dob > ?", 1, getTimestamp(1935, 1, 1)).with(new RowListenerAdapter() { @Override public void onNext(Map<String, Object> row) { System.out.println(row); } }); }
@Test public void shouldReturnProperNulls(){ Person smith = Person.findFirst("last_name = ?", "Smith"); smith.set("graduation_date", null).saveIt(); List<Map> maps = new ArrayList<>(); Base.find("select * from people where last_name = ?", "Smith").with(new RowListenerAdapter() { @Override public void onNext(Map<String, Object> row) { Object object = row.get("GRADUATION_DATE"); the(object).shouldBeNull(); maps.add(new HashMap(row)); for (Map.Entry<String, Object> entry : row.entrySet()) { if(entry.getKey().equalsIgnoreCase("GRADUATION_DATE")){ the(entry.getValue()).shouldBeNull(); }else { the(entry.getValue()).shouldNotBeNull(); } } } }); for (Map result : maps) { Object object = result.get("GRADUATION_DATE"); the(object).shouldBeNull(); } }
@Test public void shouldUseResultSetParams(){ ArrayList<Map<String, Object>> list = new ArrayList<>(); Base.find(RowProcessor.ResultSetType.FORWARD_ONLY, RowProcessor.ResultSetConcur.READ_ONLY, 0, "select * from people").with(row -> { list.add(row); return true; }); the(list.size()).shouldEqual(4); } |
### Question:
Base { public static List<Map> findAll(String query, Object... params) { return new DB(DB.DEFAULT_NAME).findAll(query, params); } private Base(); static DB open(); static DB open(String driver, String url, String user, String password); static DB open(String driver, String url, Properties props); static DB open(String jndiName); static DB open(String jndiName, Properties jndiProperties); static DB open(DataSource dataSource); static Connection connection(); static boolean hasConnection(); static void close(boolean suppressWarning); static void close(); static Long count(String table); static Long count(String table, String query, Object... params); static Object firstCell(String query, Object... params); static List<Map> findAll(String query, Object... params); static List firstColumn(String query, Object... params); static List<Map> findAll(String query); static RowProcessor find(String query, Object ... params); static RowProcessor find(RowProcessor.ResultSetType type, RowProcessor.ResultSetConcur concur, int fetchSize, String query, Object ... params); static void find(String sql, RowListener listener); static int exec(String query); static int exec(String query, Object ... params); static void openTransaction(); static void commitTransaction(); static void rollbackTransaction(); static PreparedStatement startBatch(String parametrizedStatement); static void addBatch(PreparedStatement ps, Object... parameters); static int[] executeBatch(PreparedStatement ps); static void closePreparedStatement(PreparedStatement ps); static void attach(Connection connection); static Connection detach(); static T withDb(String jndiName, Properties jndiProperties, Supplier<T> supplier); static T withDb(DataSource dataSource, Supplier<T> supplier); static T withDb(String jndiName, Supplier<T> supplier); static T withDb(String driver, String url, Properties properties, Supplier<T> supplier); static T withDb(String driver, String url, String user, String password, Supplier<T> supplier); static T withDb(Supplier<T> supplier); }### Answer:
@Test public void testBaseFindAll() { List<Map> records = Base.findAll("select * from people"); a(records.size()).shouldBeEqual(4); }
@Test public void testBaseFindAllParametrized() { List<Map> records = Base.findAll("select * from people where last_name = ? and name = ?", "Smith", "John"); a(records.size()).shouldBeEqual(1); } |
### Question:
Base { public static int exec(String query){ return new DB(DB.DEFAULT_NAME).exec(query); } private Base(); static DB open(); static DB open(String driver, String url, String user, String password); static DB open(String driver, String url, Properties props); static DB open(String jndiName); static DB open(String jndiName, Properties jndiProperties); static DB open(DataSource dataSource); static Connection connection(); static boolean hasConnection(); static void close(boolean suppressWarning); static void close(); static Long count(String table); static Long count(String table, String query, Object... params); static Object firstCell(String query, Object... params); static List<Map> findAll(String query, Object... params); static List firstColumn(String query, Object... params); static List<Map> findAll(String query); static RowProcessor find(String query, Object ... params); static RowProcessor find(RowProcessor.ResultSetType type, RowProcessor.ResultSetConcur concur, int fetchSize, String query, Object ... params); static void find(String sql, RowListener listener); static int exec(String query); static int exec(String query, Object ... params); static void openTransaction(); static void commitTransaction(); static void rollbackTransaction(); static PreparedStatement startBatch(String parametrizedStatement); static void addBatch(PreparedStatement ps, Object... parameters); static int[] executeBatch(PreparedStatement ps); static void closePreparedStatement(PreparedStatement ps); static void attach(Connection connection); static Connection detach(); static T withDb(String jndiName, Properties jndiProperties, Supplier<T> supplier); static T withDb(DataSource dataSource, Supplier<T> supplier); static T withDb(String jndiName, Supplier<T> supplier); static T withDb(String driver, String url, Properties properties, Supplier<T> supplier); static T withDb(String driver, String url, String user, String password, Supplier<T> supplier); static T withDb(Supplier<T> supplier); }### Answer:
@Test public void testExec() { int count = Base.exec("insert into people (NAME, LAST_NAME, DOB) values('Mic', 'Jagger', ?)", getTimestamp(1962, 6, 13)); List<Map> results = Base.findAll("select * from people where last_name='Jagger'"); a(1).shouldBeEqual(results.size()); a(1).shouldBeEqual(count); }
@Test public void testExecDelete() { int count = Base.exec("delete from people"); a(4).shouldBeEqual(count); } |
### Question:
Base { public static Long count(String table) { return new DB(DB.DEFAULT_NAME).count(table); } private Base(); static DB open(); static DB open(String driver, String url, String user, String password); static DB open(String driver, String url, Properties props); static DB open(String jndiName); static DB open(String jndiName, Properties jndiProperties); static DB open(DataSource dataSource); static Connection connection(); static boolean hasConnection(); static void close(boolean suppressWarning); static void close(); static Long count(String table); static Long count(String table, String query, Object... params); static Object firstCell(String query, Object... params); static List<Map> findAll(String query, Object... params); static List firstColumn(String query, Object... params); static List<Map> findAll(String query); static RowProcessor find(String query, Object ... params); static RowProcessor find(RowProcessor.ResultSetType type, RowProcessor.ResultSetConcur concur, int fetchSize, String query, Object ... params); static void find(String sql, RowListener listener); static int exec(String query); static int exec(String query, Object ... params); static void openTransaction(); static void commitTransaction(); static void rollbackTransaction(); static PreparedStatement startBatch(String parametrizedStatement); static void addBatch(PreparedStatement ps, Object... parameters); static int[] executeBatch(PreparedStatement ps); static void closePreparedStatement(PreparedStatement ps); static void attach(Connection connection); static Connection detach(); static T withDb(String jndiName, Properties jndiProperties, Supplier<T> supplier); static T withDb(DataSource dataSource, Supplier<T> supplier); static T withDb(String jndiName, Supplier<T> supplier); static T withDb(String driver, String url, Properties properties, Supplier<T> supplier); static T withDb(String driver, String url, String user, String password, Supplier<T> supplier); static T withDb(Supplier<T> supplier); }### Answer:
@Test public void testCount(){ a(Base.count("people")).shouldBeEqual(4); } |
### Question:
DefaultDialect implements Dialect { @Override public String selectStar(String table) { return "SELECT * FROM " + table; } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testSelectStar() { a(dialect.selectStar("people")).shouldBeEqual("SELECT * FROM people"); }
@Test public void testSelectStarWithQuery() { a(dialect.selectStar("people", "name = ?")).shouldBeEqual("SELECT * FROM people WHERE name = ?"); } |
### Question:
DefaultDialect implements Dialect { @Override public String selectStarParametrized(String table, String ... parameters) { StringBuilder sql = new StringBuilder().append("SELECT * FROM ").append(table).append(" WHERE "); join(sql, parameters, " = ? AND "); sql.append(" = ?"); return sql.toString(); } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testSelectStarParametrized() { a(dialect.selectStarParametrized("people", "name")).shouldBeEqual("SELECT * FROM people WHERE name = ?"); a(dialect.selectStarParametrized("people", "name", "last_name")).shouldBeEqual( "SELECT * FROM people WHERE name = ? AND last_name = ?"); } |
### Question:
DefaultDialect implements Dialect { @Override public String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId) { StringBuilder query = new StringBuilder().append("INSERT INTO ").append(metaModel.getTableName()).append(' '); if (columns.isEmpty()) { appendEmptyRow(metaModel, query); } else { boolean addIdGeneratorCode = (!containsId && metaModel.getIdGeneratorCode() != null); query.append('('); if (addIdGeneratorCode) { query.append(metaModel.getIdName()).append(", "); } join(query, columns, ", "); query.append(") VALUES ("); if (addIdGeneratorCode) { query.append(metaModel.getIdGeneratorCode()).append(", "); } appendQuestions(query, columns.size()); query.append(')'); } return query.toString(); } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testCreateParametrizedInsert() { a(dialect.insertParametrized(Person.getMetaModel(), Arrays.asList("name"), false)).shouldBeEqual( "INSERT INTO people (name) VALUES (?)"); a(dialect.insertParametrized(Person.getMetaModel(), Arrays.asList("name", "last_name"), false)).shouldBeEqual( "INSERT INTO people (name, last_name) VALUES (?, ?)"); }
@Test public void testInsertParametrized() { a(dialect.insertParametrized( Person.getMetaModel(), Arrays.asList("testField1", "testField2"), false)) .shouldBeEqual("INSERT INTO people (testField1, testField2) VALUES (?, ?)"); } |
### Question:
DefaultDialect implements Dialect { @Override public String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset) { LOGGER.error("ERROR!!!! Limit and Offset are not supported by DefaultDialect"); StringBuilder queryBuilder = new StringBuilder(); appendSelect(queryBuilder, tableName, columns, null, subQuery, orderBys); return queryBuilder.toString(); } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testFormSelectWithoutTableName() { final String fullQuery = "SELECT name FROM people"; a(dialect.formSelect( null, new String[]{"name"}, fullQuery, new ArrayList(), 1, 1)) .shouldBeEqual(fullQuery); }
@Test public void testFormSelectWithTableName() { a(dialect.formSelect("people", null, null, new ArrayList<String>(), 1, 1)) .shouldBeEqual("SELECT * FROM people"); a(dialect.formSelect("people", null, "name = ?", new ArrayList<String>(), 1, 1)) .shouldBeEqual("SELECT * FROM people WHERE name = ?"); a(dialect.formSelect("people", null, "name = ?", Arrays.asList("name"), 1, 1)) .shouldBeEqual("SELECT * FROM people WHERE name = ? ORDER BY name"); a(dialect.formSelect("people", null, null, Arrays.asList("last_name", "name"), 1, 1)) .shouldBeEqual("SELECT * FROM people ORDER BY last_name, name"); }
@Test public void testFormSelectWithOrderBy() { a(dialect.formSelect( "people", null, " ORDER by last_name", new ArrayList<String>(), 1, 1)) .shouldBeEqual("SELECT * FROM people ORDER by last_name"); } |
### Question:
DefaultDialect implements Dialect { @Override public String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount) { String targetTable = metaModelOf(association.getTargetClass()).getTableName(); StringBuilder query = new StringBuilder().append("SELECT ").append(targetTable).append(".*, t.") .append(association.getSourceFkName()).append(" AS ").append(sourceFkColumnName).append(" FROM ") .append(targetTable).append(" INNER JOIN ").append(association.getJoin()).append(" t ON ") .append(targetTable).append('.').append(association.getTargetPk()).append(" = t.") .append(association.getTargetFkName()).append(" WHERE t.").append(association.getSourceFkName()) .append(" IN ("); appendQuestions(query, questionsCount); query.append(')'); return query.toString(); } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testMany2ManyAssoc() { String expectedJoinQuery = "SELECT " + "programmers_projects.*, " + "t.assignment_id AS programmer_id " + "FROM " + "programmers_projects " + "INNER JOIN issue_assignments t ON programmers_projects.id = t.programmer_id " + "WHERE t.assignment_id IN (?)"; Many2ManyAssociation association = new Many2ManyAssociation( Programmer.class, Assignment.class, "issue_assignments", "assignment_id", "programmer_id"); String query = dialect.selectManyToManyAssociation( association, "programmer_id", 1); a(query).shouldBeEqual(expectedJoinQuery); } |
### Question:
DefaultDialect implements Dialect { @Override public String deleteManyToManyAssociation(Many2ManyAssociation association) { return "DELETE FROM " + association.getJoin() + " WHERE " + association.getSourceFkName() + " = ? AND " + association.getTargetFkName() + " = ?"; } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testDeleteManyToManyAssociation() { String expectedQuery = "DELETE FROM issue_assignments " + "WHERE assignment_id = ? AND programmer_id = ?"; Many2ManyAssociation association = new Many2ManyAssociation( Programmer.class, Assignment.class, "issue_assignments", "assignment_id", "programmer_id"); String query = dialect.deleteManyToManyAssociation(association); a(query).shouldBeEqual(expectedQuery); } |
### Question:
DefaultDialect implements Dialect { @Override public String selectExists(MetaModel metaModel) { return "SELECT " + metaModel.getIdName() + " FROM " + metaModel.getTableName() + " WHERE " + metaModel.getIdName() + " = ?"; } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testSelectExist() { a(dialect.selectExists( Person.getMetaModel())) .shouldBeEqual("SELECT id FROM people WHERE id = ?"); } |
### Question:
DefaultDialect implements Dialect { @Override public String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements) { StringBuilder query = new StringBuilder().append("INSERT INTO ").append(metaModel.getTableName()).append(' '); if (attributes.isEmpty()) { appendEmptyRow(metaModel, query); } else { boolean addIdGeneratorCode = (metaModel.getIdGeneratorCode() != null && attributes.get(metaModel.getIdName()) == null); query.append('('); if (addIdGeneratorCode) { query.append(metaModel.getIdName()).append(", "); } join(query, attributes.keySet(), ", "); query.append(") VALUES ("); if (addIdGeneratorCode) { query.append(metaModel.getIdGeneratorCode()).append(", "); } Iterator<Object> it = attributes.values().iterator(); appendValue(query, it.next()); while (it.hasNext()) { query.append(", "); appendValue(query, it.next(), replacements); } query.append(')'); } return query.toString(); } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testInsertStatement(){ Map<String, Object> x = new CaseInsensitiveMap(); x.put("testField", "testValue"); a(dialect.insert( Person.getMetaModel(), x)) .shouldBeEqual("INSERT INTO people (testField) VALUES ('testValue')"); x.put("testField2", "testValue2"); a(dialect.insert( Person.getMetaModel(), x)) .shouldBeEqual("INSERT INTO people (testField, testField2) VALUES ('testValue', 'testValue2')"); } |
### Question:
DefaultDialect implements Dialect { @Override public String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements) { if (attributes.isEmpty()) { throw new NoSuchElementException("No attributes set, can't create an update statement."); } StringBuilder query = new StringBuilder().append("UPDATE ").append(metaModel.getTableName()).append(" SET "); String idName = metaModel.getIdName(); Map<String, Object> attributesWithoutId = new CaseInsensitiveMap<>(attributes); attributesWithoutId.remove(idName); Iterator<Entry<String, Object>> it = attributesWithoutId.entrySet().iterator(); for (;;) { Entry<String, Object> attribute = it.next(); query.append(attribute.getKey()).append(" = "); appendValue(query, attribute.getValue(), replacements); if (it.hasNext()) { query.append(", "); } else { break; } } if (metaModel.getCompositeKeys() == null){ query.append(" WHERE ").append(idName).append(" = ").append(attributes.get(idName)); } else { String[] compositeKeys = metaModel.getCompositeKeys(); for (int i = 0; i < compositeKeys.length; i++) { query.append(i == 0 ? " WHERE " : " AND ").append(compositeKeys[i]).append(" = "); appendValue(query, attributes.get(compositeKeys[i])); } } return query.toString(); } @Override String selectStar(String table); @Override String selectStar(String table, String where); @Override String selectStarParametrized(String table, String ... parameters); @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); @Override Object overrideDriverTypeConversion(MetaModel mm, String attributeName, Object value); @Override String selectCount(String from); @Override String selectCount(String table, String where); @Override String selectExists(MetaModel metaModel); @Override String selectManyToManyAssociation(Many2ManyAssociation association, String sourceFkColumnName, int questionsCount); @Override String insertManyToManyAssociation(Many2ManyAssociation association); @Override String insertParametrized(MetaModel metaModel, List<String> columns, boolean containsId); @Override String deleteManyToManyAssociation(Many2ManyAssociation association); @Override String insert(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); @Override String update(MetaModel metaModel, Map<String, Object> attributes, String ... replacements); }### Answer:
@Test public void testUpdateStatement() { Map<String, Object> x = new CaseInsensitiveMap(); x.put("testField", "testValue"); x.put("id", "1"); a(dialect.update( Person.getMetaModel(), x)) .shouldBeEqual("UPDATE people SET testField = 'testValue' WHERE id = 1"); } |
### Question:
PostgreSQLDialect extends DefaultDialect { @Override public String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset) { StringBuilder fullQuery = new StringBuilder(); appendSelect(fullQuery, tableName, columns, null, subQuery, orderBys); if(limit != -1){ fullQuery.append(" LIMIT ").append(limit); } if(offset != -1){ fullQuery.append(" OFFSET ").append(offset); } return fullQuery.toString(); } @Override String formSelect(String tableName, String[] columns, String subQuery, List<String> orderBys, long limit, long offset); }### Answer:
@Test public void testFormSelectWithoutTableName() { final String fullQuery = "SELECT name FROM people"; a(dialect.formSelect(null, new String[]{"name"}, fullQuery, new ArrayList<String>(), -1, -1)).shouldBeEqual(fullQuery); }
@Test public void testFormSelectWithTableName() { a(dialect.formSelect("people", null, null, new ArrayList<String>(), -1, -1)).shouldBeEqual("SELECT * FROM people"); a(dialect.formSelect("people", null, "name = ?", new ArrayList<String>(), -1, -1)).shouldBeEqual("SELECT * FROM people WHERE name = ?"); a(dialect.formSelect("people", null, "name = ?", Arrays.asList("name"), -1, -1)).shouldBeEqual("SELECT * FROM people WHERE name = ? ORDER BY name"); a(dialect.formSelect("people", null, null, Arrays.asList("last_name", "name"), -1, -1)).shouldBeEqual("SELECT * FROM people ORDER BY last_name, name"); }
@Test public void testFormSelectWithLimitOffset() { a(dialect.formSelect("people", null, null, new ArrayList<String>(), 1, -1)).shouldBeEqual("SELECT * FROM people LIMIT 1"); a(dialect.formSelect("people", null, null, new ArrayList<String>(), -1, 1)).shouldBeEqual("SELECT * FROM people OFFSET 1"); a(dialect.formSelect("people", null, null, new ArrayList<String>(), 1, 1)).shouldBeEqual("SELECT * FROM people LIMIT 1 OFFSET 1"); a(dialect.formSelect("people", null, "last_name = ?", new ArrayList<String>(), 1, 10)).shouldBeEqual("SELECT * FROM people WHERE last_name = ? LIMIT 1 OFFSET 10"); a(dialect.formSelect("people", null, "name = ?", Arrays.asList("name"), 10, 10)).shouldBeEqual("SELECT * FROM people WHERE name = ? ORDER BY name LIMIT 10 OFFSET 10"); } |
### Question:
LazyList extends AbstractLazyList<T> implements Externalizable { public String toSql() { return toSql(true); } protected LazyList(String subQuery, MetaModel metaModel, Object... params); protected LazyList(boolean forPaginator, MetaModel metaModel, String fullQuery, Object... params); protected LazyList(); LazyList<E> limit(long limit); LazyList<E> offset(long offset); LazyList<E> orderBy(String orderBy); LazyList<E> include(Class<? extends Model>... classes); List<Map<String, Object>> toMaps(); String toXml(boolean pretty, boolean declaration, String... attrs); String toJson(boolean pretty, String ... attrs); LazyList<E> load(); String toSql(); String toSql(boolean showParameters); List collect(String attributeName); Set collectDistinct(String attributeName); List collect(String attributeName, String filterAttribute, Object filterValue); Set collectDistinct(String attributeName, String filterAttribute, Object filterValue); void dump(); void dump(OutputStream out); @Override void writeExternal(ObjectOutput out); @Override @SuppressWarnings("unchecked") void readExternal(ObjectInput in); }### Answer:
@Test public void shouldGenerateSqlWithParameters() { a(Person.where("name = ? AND last_name = ?", "John", "Doe").toSql(true) .endsWith(", with parameters: John, Doe")).shouldBeTrue(); } |
### Question:
Escape { public static void html(StringBuilder sb, String html) { for (int i = 0; i < html.length(); i++) { char c = html.charAt(i); switch (c) { case '&': sb.append("&"); break; case '"': sb.append("""); break; case '\'': sb.append("'"); break; case '<': sb.append("<"); break; case '>': sb.append(">"); break; default: sb.append(c); } } } private Escape(); static void html(StringBuilder sb, String html); static String html(String html); static void xml(StringBuilder sb, String xml); static String xml(String xml); }### Answer:
@Test public void shouldEscapeBasicHTML(){ the(Escape.html("<script>alert(\"This & that, it's the problem.\");</script>")).shouldBeEqual( "<script>alert("This & that, it's the problem.");</script>"); }
@Test public void shouldNotEscapeHighUnicode() { String unicode = "\u30D5\u30EC\u30FC\u30E0\u30EF\u30FC\u30AF\u306E\u30D9\u30F3\u30C1\u30DE\u30FC\u30AF"; the(Escape.html(unicode)).shouldBeEqual(unicode); } |
### Question:
Collections { public static <K, V> Map<K, V> map(Object... keysAndValues) { if (keysAndValues.length % 2 != 0) { throw new IllegalArgumentException("number of arguments must be even"); } Map<K, V> map = new HashMap<K, V>(Math.max(keysAndValues.length, 16)); for (int i = 0; i < keysAndValues.length;) { map.put((K) keysAndValues[i++], (V) keysAndValues[i++]); } return map; } private Collections(); static T[] arr(T... values); static T[] array(T... values); static Set<T> set(T... values); static Map<K, V> map(Object... keysAndValues); static List<T> li(T... values); static List<T> list(T... values); }### Answer:
@Test(expected = IllegalArgumentException.class) public void shouldRejectOddNumberOfArguments(){ Collections.map("hi"); }
@Test public void shouldCreateProperMap(){ Map<String, Object> person = Collections.map("name", "James", "last_name", "Belushi"); a(person.get("name")).shouldBeEqual("James"); a(person.get("last_name")).shouldBeEqual("Belushi"); } |
### Question:
Collections { public static <T> T[] array(T... values) { return values; } private Collections(); static T[] arr(T... values); static T[] array(T... values); static Set<T> set(T... values); static Map<K, V> map(Object... keysAndValues); static List<T> li(T... values); static List<T> list(T... values); }### Answer:
@Test public void shouldCreateArray(){ String[] ar = Collections.array("John", "James", "Mary", "Keith"); a(ar.length).shouldBeEqual(4); a(ar[0]).shouldBeEqual("John"); a(ar[1]).shouldBeEqual("James"); a(ar[2]).shouldBeEqual("Mary"); a(ar[3]).shouldBeEqual("Keith"); } |
### Question:
Collections { public static <T> List<T> list(T... values) { return new ArrayList<T>(Arrays.asList(values)); } private Collections(); static T[] arr(T... values); static T[] array(T... values); static Set<T> set(T... values); static Map<K, V> map(Object... keysAndValues); static List<T> li(T... values); static List<T> list(T... values); }### Answer:
@Test public void shouldCreateList(){ List<String> list = Collections.list("John", "James", "Mary", "Keith"); list.add("hello"); a(list.size()).shouldBeEqual(5); a(list.get(0)).shouldBeEqual("John"); a(list.get(1)).shouldBeEqual("James"); a(list.get(2)).shouldBeEqual("Mary"); a(list.get(3)).shouldBeEqual("Keith"); } |
### Question:
Util { public static String join(String[] array, String delimiter) { if (empty(array)) { return ""; } StringBuilder sb = new StringBuilder(); join(sb, array, delimiter); return sb.toString(); } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void testJoin(){ String[] arr = {"first", "second", "third", "fourth"}; a("first, second, third, fourth").shouldBeEqual(Util.join(Arrays.asList(arr), ", ")); }
@Test public void testJoinCollection() { StringBuilder sb = new StringBuilder(); Collection<String> set = new LinkedHashSet<String>(); Util.join(sb, set, ", "); the(sb.toString()).shouldBeEqual(""); sb = new StringBuilder(); set.add("foo"); Util.join(sb, set, ", "); the(sb.toString()).shouldBeEqual("foo"); sb = new StringBuilder(); set.add("bar"); Util.join(sb, set, ", "); the(sb.toString()).shouldBeEqual("foo, bar"); }
@Test public void testJoinArray() { StringBuilder sb = new StringBuilder(); List<String> list = new ArrayList<String>(); Util.join(sb, list.toArray(new String[list.size()]), ", "); the(sb.toString()).shouldBeEqual(""); sb = new StringBuilder(); list.add("foo"); Util.join(sb, list.toArray(new String[list.size()]), ", "); the(sb.toString()).shouldBeEqual("foo"); sb = new StringBuilder(); list.add("bar"); Util.join(sb, list.toArray(new String[list.size()]), ", "); the(sb.toString()).shouldBeEqual("foo, bar"); }
@Test public void testJoinList() { StringBuilder sb = new StringBuilder(); List<String> list = new ArrayList<String>(); Util.join(sb, list, ", "); the(sb.toString()).shouldBeEqual(""); sb = new StringBuilder(); list.add("foo"); Util.join(sb, list, ", "); the(sb.toString()).shouldBeEqual("foo"); sb = new StringBuilder(); list.add("bar"); Util.join(sb, list, ", "); the(sb.toString()).shouldBeEqual("foo, bar"); } |
### Question:
Util { public static String[] split(String input, String delimiters) { if (input == null) { throw new NullPointerException("input cannot be null"); } List<String> tokens = new ArrayList<String>(); StringTokenizer st = new StringTokenizer(input, delimiters); while(st.hasMoreTokens()) { tokens.add(st.nextToken().trim()); } return tokens.toArray(new String[tokens.size()]); } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void testSplit(){ String[] split = Util.split("", ','); the(split.length).shouldBeEqual(0); split = Util.split(" ", ','); the(split.length).shouldBeEqual(1); the(split[0]).shouldBeEqual(""); split = Util.split("a..b", '.'); the(split.length).shouldBeEqual(2); the(split[0]).shouldBeEqual("a"); the(split[1]).shouldBeEqual("b"); split = Util.split("a . . b", '.'); the(split.length).shouldBeEqual(3); the(split[0]).shouldBeEqual("a"); the(split[1]).shouldBeEqual(""); the(split[2]).shouldBeEqual("b"); split = Util.split(" Hello, Dolly, my darling ", ','); the(split.length).shouldBeEqual(3); the(split[0]).shouldBeEqual("Hello"); the(split[1]).shouldBeEqual("Dolly"); the(split[2]).shouldBeEqual("my darling"); split = Util.split("/blog/*items", '/'); the(split.length).shouldBeEqual(2); the(split[0]).shouldBeEqual("blog"); the(split[1]).shouldBeEqual("*items"); } |
### Question:
Util { public static byte[] bytes(InputStream in) throws IOException { if (in == null) { throw new IllegalArgumentException("input stream cannot be null"); } ByteArrayOutputStream os = null; try { os = new ByteArrayOutputStream(1024); byte[] bytes = new byte[1024]; int len; while ((len = in.read(bytes)) != -1) { os.write(bytes, 0, len); } return os.toByteArray(); } finally { closeQuietly(os); } } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void shouldReadBytesFromStream() throws IOException { byte[] bytes = Util.bytes(UtilTest.class.getResourceAsStream("/text.txt")); a(new String(bytes)).shouldBeEqual("hello"); } |
### Question:
Util { public static byte[] readResourceBytes(String resourceName) { InputStream is = Util.class.getResourceAsStream(resourceName); try { return bytes(is); } catch (IOException e) { throw new RuntimeException(e); } finally { closeQuietly(is); } } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void shouldReadBytesFromResource() throws IOException { byte[] bytes = Util.readResourceBytes("/pdf_implementation.pdf"); a(bytes.length).shouldBeEqual(174230); } |
### Question:
Util { public static String read(InputStream in) throws IOException { return read(in, "UTF-8"); } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void shouldReadUTF8() throws IOException { it(Util.read(getClass().getResourceAsStream("/test.txt"), "UTF-8")).shouldBeEqual("чебурашка"); it(Util.read(getClass().getResourceAsStream("/test.txt"))).shouldBeEqual("чебурашка"); } |
### Question:
Util { public static String readResource(String resourceName) { return readResource(resourceName, "UTF-8"); } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void shouldReadLargeUTF8() throws IOException { Util.readResource("/large.txt"); } |
### Question:
Util { public static boolean blank(Object value) { return value == null || value.toString().trim().length() == 0; } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void testBlankString(){ a(Util.blank(null)).shouldBeTrue(); a(Util.blank("")).shouldBeTrue(); a(Util.blank(" ")).shouldBeTrue(); a(Util.blank("\t ")).shouldBeTrue(); a(Util.blank(' ')).shouldBeTrue(); a(Util.blank('\t')).shouldBeTrue(); a(Util.blank(new StringBuilder())).shouldBeTrue(); a(Util.blank("Foo")).shouldBeFalse(); a(Util.blank("A")).shouldBeFalse(); a(Util.blank('A')).shouldBeFalse(); a(Util.blank(new StringBuilder().append("Bar"))).shouldBeFalse(); } |
### Question:
Util { public static boolean empty(Object[] array) { return array == null || array.length == 0; } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void testEmptyArray() { a(Util.empty((Object[]) null)).shouldBeTrue(); a(Util.empty(new Object[] {})).shouldBeTrue(); a(Util.empty(new Object[] { 1 })).shouldBeFalse(); a(Util.empty(new String[] { "foo", "bar" })).shouldBeFalse(); }
@Test public void testEmptyCollection() { a(Util.empty((Collection<Object>) null)).shouldBeTrue(); a(Util.empty(new ArrayList())).shouldBeTrue(); a(Util.empty(Collections.list("Hello"))).shouldBeFalse(); } |
### Question:
Util { public static void repeat(StringBuilder sb, String str, int count) { for (int i = 0; i < count; i++) { sb.append(str); } } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void testRepeat() { StringBuilder sb = new StringBuilder(); Util.repeat(sb, "na", -1); the(sb.toString()).shouldBeEqual(""); sb = new StringBuilder(); Util.repeat(sb, "na", 0); the(sb.toString()).shouldBeEqual(""); sb = new StringBuilder(); Util.repeat(sb, "na", 1); the(sb.toString()).shouldBeEqual("na"); sb = new StringBuilder(); Util.repeat(sb, "na", 16); the(sb.toString()).shouldBeEqual("nananananananananananananananana"); } |
### Question:
Util { public static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count) { if (count > 0) { sb.append(str); for (int i = 1; i < count; i++) { sb.append(delimiter); sb.append(str); } } } private Util(); static byte[] readResourceBytes(String resourceName); static String readResource(String resourceName); static String readResource(String resourceName, String charset); static String readFile(String fileName); static String readFile(String fileName, String charset); static void closeQuietly(AutoCloseable autoCloseable); static void closeQuietly(AutoCloseable ... autoCloseable); static void closeQuietly(List<T> autoCloseable); static String read(InputStream in); static String read(InputStream in, String charset); static byte[] bytes(InputStream in); static byte[] read(File file); static List<String> getResourceLines(String resourceName); static boolean blank(Object value); static boolean empty(Object[] array); static boolean empty(Collection<?> collection); static String join(String[] array, String delimiter); static String[] split(String input, String delimiters); static String[] split(String input, char delimiter); static String join(Collection<?> collection, String delimiter); static void join(StringBuilder sb, Collection<?> collection, String delimiter); static void join(StringBuilder sb, Object[] array, String delimiter); static void repeat(StringBuilder sb, String str, int count); static void joinAndRepeat(StringBuilder sb, String str, String delimiter, int count); static void saveTo(String path, InputStream in); static String getCauseMessage(Throwable throwable); static String getStackTraceString(Throwable throwable); static void saveTo(String path, byte[] content); static String toBase64(byte[] input); static byte[] fromBase64(String input); String[] arr(String ... params); static Properties readProperties(String fileOrResource); static boolean createTree(Path path); static void recursiveDelete(Path directory); }### Answer:
@Test public void testJoinAndRepeat() { StringBuilder sb = new StringBuilder(); Util.joinAndRepeat(sb, "na", ", ", -1); the(sb.toString()).shouldBeEqual(""); sb = new StringBuilder(); Util.joinAndRepeat(sb, "na", ", ", 0); the(sb.toString()).shouldBeEqual(""); sb = new StringBuilder(); Util.joinAndRepeat(sb, "na", ", ", 1); the(sb.toString()).shouldBeEqual("na"); sb = new StringBuilder(); Util.joinAndRepeat(sb, "na", ", ", 16); the(sb.toString()).shouldBeEqual("na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na"); } |
### Question:
Convert { public static BigDecimal toBigDecimal(Object value) { if (value == null) { return null; } else if (value instanceof BigDecimal) { return (BigDecimal) value; } else { try { return new BigDecimal(value.toString().trim()); } catch (NumberFormatException e) { throw new ConversionException("failed to convert: '" + value + "' to BigDecimal", e); } } } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldCovertToBigDecimal() { Object object = Convert.toBigDecimal(1); the(object).shouldBeA(BigDecimal.class); a(object).shouldBeEqual(1); object = Convert.toBigDecimal("1"); the(object).shouldBeA(BigDecimal.class); a(object).shouldBeEqual(1); object = Convert.toBigDecimal(1d); the(object).shouldBeA(BigDecimal.class); a(object).shouldBeEqual(1); object = Convert.toBigDecimal(1L); the(object).shouldBeA(BigDecimal.class); a(object).shouldBeEqual(1); } |
### Question:
Convert { public static Long toLong(Object value) { if (value == null) { return null; } else if (value instanceof Long) { return (Long) value; } else if (value instanceof Number) { return ((Number) value).longValue(); } else if (value instanceof java.util.Date) { return ((java.util.Date) value).getTime(); } else { try { return Long.valueOf(value.toString().trim()); } catch (NumberFormatException e) { throw new ConversionException("failed to convert: '" + value + "' to Long", e); } } } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldCovertToLong() { Object object = Convert.toLong(1); the(object).shouldBeA(Long.class); a(object).shouldBeEqual(1); object = Convert.toLong("1"); the(object).shouldBeA(Long.class); a(object).shouldBeEqual(1); object = Convert.toLong(1d); the(object).shouldBeA(Long.class); a(object).shouldBeEqual(1); object = Convert.toLong(new BigDecimal(1)); the(object).shouldBeA(Long.class); a(object).shouldBeEqual(1); Date date = new Date(1416127392928L); object = Convert.toLong(date); the(object).shouldBeA(Long.class); a(object).shouldBeEqual(1416127392928L); } |
### Question:
Convert { public static Double toDouble(Object value) { if (value == null) { return null; } else if (value instanceof Double) { return (Double) value; } else if (value instanceof Number) { return ((Number) value).doubleValue(); } else { try { return Double.valueOf(value.toString().trim()); } catch (NumberFormatException e) { throw new ConversionException("failed to convert: '" + value + "' to Double", e); } } } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldCovertToDouble() { Object object = Convert.toDouble(1); the(object).shouldBeA(Double.class); a(object).shouldBeEqual(1); object = Convert.toDouble("1"); the(object).shouldBeA(Double.class); a(object).shouldBeEqual(1); object = Convert.toDouble(1L); the(object).shouldBeA(Double.class); a(object).shouldBeEqual(1); object = Convert.toDouble(new BigDecimal(1)); the(object).shouldBeA(Double.class); a(object).shouldBeEqual(1); } |
### Question:
Convert { public static Float toFloat(Object value) { if (value == null) { return null; } else if (value instanceof Float) { return (Float) value; } else if (value instanceof Number) { return ((Number) value).floatValue(); } else { return Float.valueOf(value.toString().trim()); } } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldCovertToFloat() { Object object = Convert.toFloat(1F); the(object).shouldBeA(Float.class); a(object).shouldBeEqual(1); object = Convert.toFloat("1"); the(object).shouldBeA(Float.class); a(object).shouldBeEqual(1); object = Convert.toFloat(1L); the(object).shouldBeA(Float.class); a(object).shouldBeEqual(1); object = Convert.toFloat(new BigDecimal(1)); the(object).shouldBeA(Float.class); a(object).shouldBeEqual(1); } |
### Question:
Convert { public static Short toShort(Object value) { if (value == null) { return null; } else if (value instanceof Short) { return (Short) value; } else if (value instanceof Number) { return ((Number) value).shortValue(); } else { try { return Short.valueOf(value.toString().trim()); } catch (NumberFormatException e) { throw new ConversionException("failed to convert: '" + value + "' to Short", e); } } } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldCovertToShort() { Object object = Convert.toShort(1F); the(object).shouldBeA(Short.class); a(object).shouldBeEqual(1); object = Convert.toShort("1"); the(object).shouldBeA(Short.class); a(object).shouldBeEqual(1); object = Convert.toShort(1L); the(object).shouldBeA(Short.class); a(object).shouldBeEqual(1); object = Convert.toShort(new BigDecimal(1)); the(object).shouldBeA(Short.class); a(object).shouldBeEqual(1); } |
### Question:
Convert { public static Boolean toBoolean(Object value) { if (value == null) { return false; } else if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof BigDecimal) { return value.equals(BigDecimal.ONE); } else if (value instanceof Number) { return ((Number) value).intValue() == 1; } else if (value instanceof Character) { char c = (Character) value; return c == 't' || c == 'T' || c == 'y' || c == 'Y' || c == '1'; } else { String str = value.toString(); return str.equalsIgnoreCase("true") || str.equalsIgnoreCase("t") || str.equalsIgnoreCase("yes") || str.equalsIgnoreCase("y") || str.equals("1") || Boolean.parseBoolean(str); } } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldCovertToBoolean() { a(Convert.toBoolean(null)).shouldBeFalse(); a(Convert.toBoolean("true")).shouldBeTrue(); a(Convert.toBoolean("false")).shouldBeFalse(); a(Convert.toBoolean("TRUE")).shouldBeTrue(); a(Convert.toBoolean("FALSE")).shouldBeFalse(); a(Convert.toBoolean("True")).shouldBeTrue(); a(Convert.toBoolean("False")).shouldBeFalse(); a(Convert.toBoolean("yes")).shouldBeTrue(); a(Convert.toBoolean("no")).shouldBeFalse(); a(Convert.toBoolean("YES")).shouldBeTrue(); a(Convert.toBoolean("NO")).shouldBeFalse(); a(Convert.toBoolean("Yes")).shouldBeTrue(); a(Convert.toBoolean("No")).shouldBeFalse(); a(Convert.toBoolean("t")).shouldBeTrue(); a(Convert.toBoolean("f")).shouldBeFalse(); a(Convert.toBoolean("T")).shouldBeTrue(); a(Convert.toBoolean("F")).shouldBeFalse(); a(Convert.toBoolean("y")).shouldBeTrue(); a(Convert.toBoolean("n")).shouldBeFalse(); a(Convert.toBoolean("Y")).shouldBeTrue(); a(Convert.toBoolean("N")).shouldBeFalse(); a(Convert.toBoolean("1")).shouldBeTrue(); a(Convert.toBoolean("0")).shouldBeFalse(); a(Convert.toBoolean('t')).shouldBeTrue(); a(Convert.toBoolean('f')).shouldBeFalse(); a(Convert.toBoolean('T')).shouldBeTrue(); a(Convert.toBoolean('F')).shouldBeFalse(); a(Convert.toBoolean('y')).shouldBeTrue(); a(Convert.toBoolean('n')).shouldBeFalse(); a(Convert.toBoolean('Y')).shouldBeTrue(); a(Convert.toBoolean('N')).shouldBeFalse(); a(Convert.toBoolean('1')).shouldBeTrue(); a(Convert.toBoolean('0')).shouldBeFalse(); a(Convert.toBoolean(1)).shouldBeTrue(); a(Convert.toBoolean(0)).shouldBeFalse(); a(Convert.toBoolean(1L)).shouldBeTrue(); a(Convert.toBoolean(0L)).shouldBeFalse(); a(Convert.toBoolean(1f)).shouldBeTrue(); a(Convert.toBoolean(0f)).shouldBeFalse(); a(Convert.toBoolean(1d)).shouldBeTrue(); a(Convert.toBoolean(0d)).shouldBeFalse(); short t = (short)1; short f = (short)0; a(Convert.toBoolean(t)).shouldBeTrue(); a(Convert.toBoolean(f)).shouldBeFalse(); } |
### Question:
Convert { public static String toIsoString(java.util.Date date) { if (date == null) { return null; } else if (date instanceof java.sql.Date) { return date.toString(); } Calendar cal = THREADLOCAL_CAL_UTC.get(); cal.setTime(date); int year = cal.get(Calendar.YEAR); int month = cal.get(Calendar.MONTH) + 1; int day = cal.get(Calendar.DAY_OF_MONTH); int hour = cal.get(Calendar.HOUR_OF_DAY); int minute = cal.get(Calendar.MINUTE); int second = cal.get(Calendar.SECOND); char[] buf = new char[20]; buf[0] = Character.forDigit(year/1000, 10); buf[1] = Character.forDigit((year/100)%10, 10); buf[2] = Character.forDigit((year/10)%10, 10); buf[3] = Character.forDigit(year%10, 10); buf[4] = '-'; buf[5] = Character.forDigit(month/10, 10); buf[6] = Character.forDigit(month%10, 10); buf[7] = '-'; buf[8] = Character.forDigit(day/10, 10); buf[9] = Character.forDigit(day%10, 10); buf[10] = 'T'; buf[11] = Character.forDigit(hour/10, 10); buf[12] = Character.forDigit(hour%10, 10); buf[13] = ':'; buf[14] = Character.forDigit(minute/10, 10); buf[15] = Character.forDigit(minute%10, 10); buf[16] = ':'; buf[17] = Character.forDigit(second/10, 10); buf[18] = Character.forDigit(second%10, 10); buf[19] = 'Z'; return new String(buf); } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldCovertToIsoString() { Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); cal.set(1970, 0, 1, 0, 0, 0); the(Convert.toIsoString(cal.getTime())).shouldBeEqual("1970-01-01T00:00:00Z"); cal.set(1912, 5, 23, 2, 15, 47); the(Convert.toIsoString(cal.getTime())).shouldBeEqual("1912-06-23T02:15:47Z"); cal.set(2014, 11, 31, 23, 59, 59); the(Convert.toIsoString(cal.getTime())).shouldBeEqual("2014-12-31T23:59:59Z"); } |
### Question:
Convert { public static byte[] toBytes(Object value) { if (value == null) { return null; } else if (value instanceof byte[]) { return (byte[]) value; } else if (value instanceof Blob) { return toBytes((Blob) value); } else { return toString(value).getBytes(); } } private Convert(); static String toString(Object value); static Boolean toBoolean(Object value); static java.sql.Date toSqlDate(Object value); static java.sql.Date truncateToSqlDate(Object value); static java.sql.Date truncateToSqlDate(long time); static String toIsoString(java.util.Date date); static Double toDouble(Object value); static java.sql.Time toTime(Object value); static java.sql.Timestamp toTimestamp(Object value); static Float toFloat(Object value); static Long toLong(Object value); static Integer toInteger(Object value); static BigDecimal toBigDecimal(Object value); static byte[] toBytes(Object value); static byte[] toBytes(Blob blob); static Short toShort(Object value); }### Answer:
@Test public void shouldToBytesCovertNull() { the(Convert.toBytes((Object) null)).shouldBeNull(); } |
### Question:
TomcatVersionValidator extends ValidatorBase implements IConstants, IConfigKeys { public static String getTomcatVersion(String serverInfo) { String result = null; if (serverInfo != null && !serverInfo.isEmpty()) { Debug.log("TomcatVersionValidator.getTomcatVersion() - validating ServerInfo:" + serverInfo); int currentIndex = serverInfo.indexOf(STR_APACHE_TOMCAT_SERVER_NUMBER); if (currentIndex == -1) { return null; } currentIndex += STR_APACHE_TOMCAT_SERVER_NUMBER.length(); int endIndex = serverInfo.indexOf('\n', currentIndex); if (endIndex == -1) { endIndex = serverInfo.length() - 1; } String versionLine = serverInfo.substring(currentIndex, endIndex).trim(); if (versionLine.startsWith("6.0")) { result = TOMCAT_VER_60; } else if (versionLine.startsWith("7.0")) { result = TOMCAT_VER_70; } else if (versionLine.startsWith("8.0")) { result = TOMCAT_VER_80; } else if (versionLine.startsWith("8.5")) { result = TOMCAT_VER_85; } Debug.log("TomcatVersionValidator.getTomcatVersion() - version:" + versionLine + " found version: " + result); } return result; } TomcatVersionValidator(); ValidationResult isTomcatVersionValid(
String catalinaHomeDir,
Map props,
IStateAccess state); void initializeValidatorMap(); static String getTomcatVersion(String serverInfo); }### Answer:
@Test public void testCheckTomcatVersionIsValid() { Assert.assertEquals(IConstants.TOMCAT_VER_60, TomcatVersionValidator.getTomcatVersion(VMWARE_TOMCAT6_SERVERINFO)); Assert.assertEquals(IConstants.TOMCAT_VER_60, TomcatVersionValidator.getTomcatVersion(WINDOWS_TOMCAT6_SERVERINFO)); Assert.assertEquals(IConstants.TOMCAT_VER_60, TomcatVersionValidator.getTomcatVersion(LINUX_TOMCAT6_SERVERINFO)); Assert.assertEquals(IConstants.TOMCAT_VER_70, TomcatVersionValidator.getTomcatVersion(LINUX_TOMCAT7_SERVERINFO)); Assert.assertEquals(IConstants.TOMCAT_VER_80, TomcatVersionValidator.getTomcatVersion(LINUX_TOMCAT8_SERVERINFO)); Assert.assertEquals(IConstants.TOMCAT_VER_85, TomcatVersionValidator.getTomcatVersion(LINUX_TOMCAT85_SERVERINFO)); Assert.assertNull(TomcatVersionValidator.getTomcatVersion(LINUX_TOMCAT5_SERVERINFO)); Assert.assertNull(TomcatVersionValidator.getTomcatVersion(null)); Assert.assertNull(TomcatVersionValidator.getTomcatVersion("")); } |
### Question:
XPathResolver implements LogicalSourceResolver<XdmItem> { @Override public ExpressionEvaluatorFactory<XdmItem> getExpressionEvaluatorFactory() { return entry -> expression -> { try { XPathSelector selector = xpath.compile(expression).load(); selector.setContextItem(entry); XdmValue value = selector.evaluate(); if (value.size() > 1) { List<String> results = new ArrayList<>(); value.forEach(i -> { String sValue = getItemStringValue(i, value); if (sValue != null) { results.add(sValue); } } ); return Optional.of(results); } else if (value.size() == 0) { return Optional.empty(); } XdmItem item = value.itemAt(0); return Optional.ofNullable(getItemStringValue(item, value)); } catch (SaxonApiException e) { throw new RuntimeException(String.format( "Error applying XPath expression [%s] to entry [%s]", entry, expression), e); } }; } XPathResolver(); XPathResolver(boolean autoNodeTextExtraction); boolean autoExtractsNodeText(); @Override SourceIterator<XdmItem> getSourceIterator(); @Override ExpressionEvaluatorFactory<XdmItem> getExpressionEvaluatorFactory(); }### Answer:
@Test public void expressionEvaluator_givenExpression_shoulReturnCorrectValue() { String expression = "./author/lower-case(.)"; ExpressionEvaluatorFactory<XdmItem> evaluatorFactory = xpathResolver.getExpressionEvaluatorFactory(); EvaluateExpression evaluateExpression = evaluatorFactory.apply(nodes.get(0)); assertThat(evaluateExpression.apply(expression).get(), is("giada de laurentiis")); }
@Test public void expressionEvaluatorWithoutAutoTextExtraction_givenExpression_shoulReturnCorrectValue() { String expression = "./author"; ExpressionEvaluatorFactory<XdmItem> evaluatorFactory = xpathResolver.getExpressionEvaluatorFactory(); EvaluateExpression evaluateExpression = evaluatorFactory.apply(nodes.get(0)); assertThat(evaluateExpression.apply(expression).get(), is("Giada De Laurentiis")); boolean autoExtractNodeText = false; xpathResolver = new XPathResolver(autoExtractNodeText); nodeIterator = xpathResolver.bindSource(LSOURCE, sourceResolver).get(); evaluatorFactory = xpathResolver.getExpressionEvaluatorFactory(); nodes = Lists.newArrayList(nodeIterator); evaluateExpression = evaluatorFactory.apply(nodes.get(0)); assertThat(evaluateExpression.apply(expression).get(), is("<author>Giada De Laurentiis</author>")); }
@Test public void expressionEvaluator_givenExpressionWithNamespace_shoulReturnCorrectValue() { Set<TriplesMap> mapping = RmlMappingLoader .build() .load(RDFFormat.TURTLE, XPathResolverTest.class.getResourceAsStream("xmlns.rml.ttl")); TriplesMap tMap = Iterables.getOnlyElement(mapping); LogicalSource lSource = tMap.getLogicalSource(); xpathResolver = new XPathResolver(); nodeIterator = xpathResolver.bindSource(lSource, nsSourceResolver).get(); nodes = Lists.newArrayList(nodeIterator); String expression = "./ex:author/lower-case(.)"; ExpressionEvaluatorFactory<XdmItem> evaluatorFactory = xpathResolver.getExpressionEvaluatorFactory(); EvaluateExpression evaluateExpression = evaluatorFactory.apply(nodes.get(0)); assertThat(evaluateExpression.apply(expression).get(), is("j k. rowling")); } |
### Question:
CarmlMapper implements Mapper, MappingCache { @Override public <T> T map(Model model, Resource resource, Set<Type> types) { if (types.size() > 1) { if (!types.stream().allMatch(t -> ((Class<?>)t).isInterface())) { throw new IllegalStateException(String.format( "Error mapping %s. In case of multiple types, mapper requires all types to be interfaces", formatResourceForLog(model, resource, namespaces, true))); } } if (types.stream().allMatch(t -> ((Class<?>)t).isInterface())) { return doMultipleInterfaceMapping(model, resource, types); } else { return doSingleTypeConcreteClassMapping(model, resource, Iterables.getOnlyElement(types)); } } CarmlMapper(); CarmlMapper(Set<Namespace> namespaces); @Override T map(Model model, Resource resource, Set<Type> types); @Override Object getCachedMapping(Resource resource, Set<Type> targetType); @Override void addCachedMapping(Resource resource, Set<Type> targetType, Object value); @Override Type getDecidableType(IRI rdfType); @Override void addDecidableType(IRI rdfType, Type type); @Override void bindInterfaceImplementation(Type interfaze, Type implementation); @Override Type getInterfaceImplementation(Type interfaze); }### Answer:
@Test public void mapper_havingMethodWithMultiplePropertyAnnotations_MapsCorrectly() { prepareTest(); CarmlMapper mapper = new CarmlMapper(); Person manu = mapper.map(model, (Resource) VF.createIRI("http: ImmutableSet.of(Person.class)); Set<Person> acquaintances = manu.getKnows(); assertThat(acquaintances, hasSize(6)); } |
### Question:
IriSafeMaker implements Function<String, String> { @Override public String apply(String s) { StringBuilder result = new StringBuilder(); s = Normalizer.normalize(s, normalizationForm); s.codePoints().flatMap(c -> { if ( Character.isAlphabetic(c) || Character.isDigit(c) || c == '-' || c == '.' || c == '_' || c == '~' || ranges.stream().anyMatch(r -> r.includes(c)) ) return IntStream.of(c); String hex = Integer.toHexString(c); hex = upperCaseHex ? hex.toUpperCase() : hex; return ("%" + hex).codePoints(); }) .forEach(c -> result.append((char) c)); return result.toString(); } IriSafeMaker(List<Range> ranges, Form normalizationForm, boolean upperCaseHex); static String makeSafe(String input, Form normalizationForm, boolean upperCaseHex); static IriSafeMaker create(Form normalizationForm, boolean upperCaseHex); static IriSafeMaker create(); @Override String apply(String s); }### Answer:
@Test public void nfkcSafeMaker_givenNormalizableToken_encodesAsExpected() { String input = "StandaardGeluidsruimteDagInDb_a_M²"; String expected = "StandaardGeluidsruimteDagInDb_a_M2"; String actual = nfkcSafeMaker.apply(input); assertEquals(expected, actual); } |
### Question:
TermGeneratorCreator { @SuppressWarnings("unchecked") TermGenerator<Value> getObjectGenerator(ObjectMap map) { return (TermGenerator<Value>) getGenerator( map, ImmutableSet.of(TermType.IRI, TermType.BLANK_NODE, TermType.LITERAL), ImmutableSet.of(IRI.class, Literal.class) ); } TermGeneratorCreator(
ValueFactory valueFactory,
String baseIri,
Function<String, String> makeIriSafe,
TemplateParser templateParser,
RmlMapper mapper
); }### Answer:
@Test public void getGenerator_withReferenceAndTemplate_throwsRuntimeException() throws Exception { TermGeneratorCreator tgc = new TermGeneratorCreator(null, "foo", null, TemplateParser.build(), null); RuntimeException exception = assertThrows(RuntimeException.class, () -> tgc.getObjectGenerator(new CarmlObjectMap("foo.bar", null, "foo{foo.bar}", TermType.LITERAL, null, null, null, null))); Assert.assertNotNull(exception); Assert.assertTrue(exception.getMessage().startsWith("2 value generators were created for term map")); }
@Test public void IriTermGenerator_withRelativeIRI_usesBaseIRI() throws Exception { ValueFactory f = SimpleValueFactory.getInstance(); String baseIri = "http: TermGeneratorCreator tgc = new TermGeneratorCreator(f, baseIri, null, TemplateParser.build(), null); String ref = "ref"; TermGenerator<Value> generator = tgc.getObjectGenerator(new CarmlObjectMap(ref, null, null, TermType.IRI, null, null, null, null)); String relativeIriPart = "/relativeIriPortion"; EvaluateExpression evaluator = Mockito.mock(EvaluateExpression.class); when(evaluator.apply(ref)).thenReturn(Optional.of(relativeIriPart)); List<Value> result = generator.apply(evaluator); Assert.assertTrue(!result.isEmpty()); Assert.assertTrue(result.get(0) instanceof IRI); Assert.assertEquals(result.get(0), f.createIRI(baseIri + relativeIriPart)); }
@Test public void IriTermGenerator_withAbsoluteIRI_usesBaseIRI() throws Exception { ValueFactory f = SimpleValueFactory.getInstance(); String baseIri = "http: TermGeneratorCreator tgc = new TermGeneratorCreator(f, baseIri, null, TemplateParser.build(), null); String ref = "ref"; TermGenerator<Value> generator = tgc.getObjectGenerator(new CarmlObjectMap(ref, null, null, TermType.IRI, null, null, null, null)); String absoluteIri = "http: EvaluateExpression evaluator = Mockito.mock(EvaluateExpression.class); when(evaluator.apply(ref)).thenReturn(Optional.of(absoluteIri)); List<Value> result = generator.apply(evaluator); Assert.assertTrue(!result.isEmpty()); Assert.assertTrue(result.get(0) instanceof IRI); Assert.assertEquals(result.get(0), f.createIRI(absoluteIri)); }
@Test public void IriTermGenerator_withFaultyIRI_throwsException() throws Exception { ValueFactory f = SimpleValueFactory.getInstance(); String baseIri = "?"; TermGeneratorCreator tgc = new TermGeneratorCreator(f, baseIri, null, TemplateParser.build(), null); String ref = "ref"; TermGenerator<Value> generator = tgc.getObjectGenerator(new CarmlObjectMap(ref, null, null, TermType.IRI, null, null, null, null)); String relativeIriPart = "/relativeIriPortion"; EvaluateExpression evaluator = Mockito.mock(EvaluateExpression.class); when(evaluator.apply(ref)).thenReturn(Optional.of(relativeIriPart)); RuntimeException exception = null; try { generator.apply(evaluator); Assert.assertTrue("This code should be unreachable", false); } catch (RuntimeException e) { exception = e; } Assert.assertNotNull(exception); Assert.assertTrue(exception.getMessage().startsWith("Could not generate a valid iri")); } |
### Question:
ParentTriplesMapper { Set<Resource> map(Set<Pair<String, Object>> joinValues) { if (joinValues.isEmpty()) { return ImmutableSet.of(); } Set<Resource> results = new LinkedHashSet<>(); getIterator.get().forEach(e -> map(e, joinValues) .forEach(results::add)); return results; } ParentTriplesMapper(
TermGenerator<Resource> subjectGenerator,
TriplesMapperComponents<T> trMapperComponents
); ParentTriplesMapper(
TermGenerator<Resource> subjectGenerator,
Supplier<Iterable<T>> getIterator,
LogicalSourceResolver.ExpressionEvaluatorFactory<T> expressionEvaluatorFactory
); }### Answer:
@Test public void parentTriplesMapper_givenJoinConditions() { when(getIterator.get()).thenReturn(ImmutableList.of(entry)); when(expressionEvaluatorFactory.apply(entry)).thenReturn(evaluate); when(subjectGenerator.apply(evaluate)).thenReturn(ImmutableList.of(SKOS.CONCEPT)); ParentTriplesMapper<Object> mapper = new ParentTriplesMapper<>(subjectGenerator, getIterator, expressionEvaluatorFactory); Set<Resource> resources = mapper.map(joinValues); assertThat(resources.size(), is(1)); assertThat(SKOS.CONCEPT, is(in(resources))); }
@Test public void parentTriplesMapper_givenMultiJoinWithNullValues_ShouldStillResolveJoin() { when(getIterator.get()).thenReturn(ImmutableList.of(entry)); when(expressionEvaluatorFactory.apply(entry)).thenReturn(evaluate); when(subjectGenerator.apply(evaluate)).thenReturn(ImmutableList.of(SKOS.CONCEPT)); ParentTriplesMapper<Object> mapper = new ParentTriplesMapper<>(subjectGenerator, getIterator, expressionEvaluatorFactory); Set<Resource> resources = mapper.map(multiJoinValues); assertThat(resources.size(), is(1)); assertThat(SKOS.CONCEPT, is(in(resources))); } |
### Question:
RmlMapper { public Model map(Set<TriplesMap> mapping) { validateMapping(mapping); Model model = new LinkedHashModel(); Set<TriplesMap> functionValueTriplesMaps = getTermMaps(mapping) .filter(t -> t.getFunctionValue() != null) .map(TermMap::getFunctionValue) .collect(ImmutableCollectors.toImmutableSet()); if(LOG.isWarnEnabled()) { boolean deprecatedFno = functionValueTriplesMaps.stream() .flatMap(triplesMap -> triplesMap.getPredicateObjectMaps().stream()) .flatMap(pom -> pom.getPredicateMaps().stream()) .anyMatch(predicateMap -> predicateMap.getConstant().equals(Rdf.Fno.old_executes)); if (deprecatedFno) { LOG.warn("Usage of deprecated predicate <{}> encountered. Support in next release is not guaranteed. Upgrade to <{}>.", Rdf.Fno.old_executes, Rdf.Fno.executes); } } Set<TriplesMap> refObjectTriplesMaps = getAllTriplesMapsUsedInRefObjectMap(mapping); mapping.stream() .filter(m -> !functionValueTriplesMaps.contains(m) || refObjectTriplesMaps.contains(m)) .forEach(m -> map(m, model)); this.sourceManager.clear(); return model; } private RmlMapper(
Function<Object, String> sourceResolver,
Map<IRI, LogicalSourceResolver<?>> logicalSourceResolvers,
Functions functions,
Form normalizationForm,
boolean iriUpperCasePercentEncoding
); static Builder newBuilder(); Form getNormalizationForm(); boolean getIriUpperCasePercentEncoding(); LogicalSourceManager getSourceManager(); Optional<ExecuteFunction> getFunction(IRI iri); Model map(Set<TriplesMap> mapping); void bindInputStream(InputStream inputStream); void bindInputStream(String name, InputStream inputStream); }### Answer:
@Test public void mapper_notFindingBoundUnnamedInputStream_shouldThrowException() { RmlMappingLoader loader = RmlMappingLoader.build(); InputStream input = RmlMapperTest.class.getResourceAsStream("simple.carml.rml.ttl"); RuntimeException exception = assertThrows(RuntimeException.class, () -> mapper.map(loader.load(RDFFormat.TURTLE, input))); assertThat(exception.getMessage(), is("attempting to get source, but no binding was present")); }
@Test public void mapper_notFindingBoundNamedInputStreams_shouldThrowException() { String streamName = "foo"; RmlMappingLoader loader = RmlMappingLoader.build(); InputStream input = RmlMapperTest.class.getResourceAsStream("simple.namedcarml.rml.ttl"); RuntimeException exception = assertThrows(RuntimeException.class, () -> mapper.map(loader.load(RDFFormat.TURTLE, input))); assertThat(exception.getMessage(), is(String.format("attempting to get source by " + "name [%s], but no such binding is present", streamName))); }
@Test public void mapper_withNoBoundSource_shouldThrowException() throws IOException { RmlMappingLoader loader = RmlMappingLoader.build(); InputStream input = RmlMapperTest.class.getResourceAsStream("simple.carml.rml.ttl"); RuntimeException exception = assertThrows(RuntimeException.class, () -> mapper.map(loader.load(RDFFormat.TURTLE, input))); assertThat(exception.getMessage(), is("attempting to get source, but no binding was present")); } |
### Question:
GetTemplateValue implements Function<EvaluateExpression, Optional<Object>> { @Override public Optional<Object> apply(EvaluateExpression evaluateExpression) { if (LOG.isTraceEnabled()) { LOG.trace("Processing template: {}", template.toTemplateString()); } Template.Builder templateBuilder = template.newBuilder(); expressions.forEach(e -> bindTemplateExpression(e, evaluateExpression, templateBuilder)); return templateBuilder.create(); } GetTemplateValue(
Template template,
Set<Expression> expressions,
Function<String, String> transformValue,
Function<Object, String> createNaturalRdfLexicalForm
); @Override Optional<Object> apply(EvaluateExpression evaluateExpression); }### Answer:
@Test public void getTemplateValue_givenValidInputAndFindingValue_performsAsExpected() { when(evaluateExpression.apply("xyz")).thenReturn(Optional.of("evaluated")); when(createNaturalRdfLexicalForm.apply("evaluated")).thenReturn("natural"); when(transformValue.apply("natural")).thenReturn("transformed"); Template template = TemplateParser.build().parse("abc{xyz}"); GetTemplateValue getTemplateValue = new GetTemplateValue( template, template.getExpressions(), transformValue, createNaturalRdfLexicalForm ); Optional<Object> templateValue = getTemplateValue.apply(evaluateExpression); String result = unpackTemplateValue(templateValue); assertThat(result, is("abctransformed")); }
@Test public void getTemplateValue_givenValidInputWithMultipleExpressions_performsAsExpected() { when(evaluateExpression.apply("xyz")).thenReturn(Optional.of("evaluated")); when(createNaturalRdfLexicalForm.apply("evaluated")).thenReturn("natural"); when(transformValue.apply("natural")).thenReturn("transformed"); Template template = TemplateParser.build().parse("abc{xyz}{xyz}"); GetTemplateValue getTemplateValue = new GetTemplateValue( template, template.getExpressions(), transformValue, createNaturalRdfLexicalForm ); Optional<Object>templateValue = getTemplateValue.apply(evaluateExpression); String result = unpackTemplateValue(templateValue); assertThat(result, is("abctransformedtransformed")); }
@Test public void getTemplateValue_givenValidInputAndNotFindingValue_returnsNoValues() { when(evaluateExpression.apply("xyz")).thenReturn(Optional.empty()); Template template = TemplateParser.build().parse("abc{xyz}"); GetTemplateValue getTemplateValue = new GetTemplateValue( template, template.getExpressions(), transformValue, createNaturalRdfLexicalForm ); Optional<Object> templateValue = getTemplateValue.apply(evaluateExpression); assertThat(templateValue, is(Optional.empty())); } |
### Question:
CsvResolver implements LogicalSourceResolver<Record> { @Override public ExpressionEvaluatorFactory<Record> getExpressionEvaluatorFactory() { return entry -> expression -> { logEvaluateExpression(expression, LOG); return Optional.ofNullable(entry.getString(expression)); }; } @Override SourceIterator<Record> getSourceIterator(); @Override ExpressionEvaluatorFactory<Record> getExpressionEvaluatorFactory(); }### Answer:
@Test public void expressionEvaluator_givenExpression_shoulReturnCorrectValue() { String expression = "Year"; Iterable<Record> recordIterator = csvResolver.bindSource(LSOURCE, sourceResolver).get(); ExpressionEvaluatorFactory<Record> evaluatorFactory = csvResolver.getExpressionEvaluatorFactory(); List<Record> records = Lists.newArrayList(recordIterator); EvaluateExpression evaluateExpression = evaluatorFactory.apply(records.get(0)); assertThat(evaluateExpression.apply(expression).get(), is("1997")); } |
### Question:
QueryUtils { public static Model getModelFromRepo(Repository repository, String sparqlQuery) { Objects.requireNonNull(repository, REPOSITORY_MSG); Objects.requireNonNull(repository, SPARQL_QUERY_MSG); return Repositories.graphQuery( repository, sparqlQuery, QueryResults::asModel ); } private QueryUtils(); static Model getModelFromRepo(Repository repository, String sparqlQuery); static Model getModelFromRepo(Repository repository, Resource... contexts); }### Answer:
@Test public void modelGetter_givenSparqlQuery_ShouldReturnAllCorrespondingStatements() { String sparqlQuery = "" + "CONSTRUCT {" + " ?s <http: + " ?s <http: + "} " + "FROM NAMED <http: + "WHERE { " + " GRAPH ?g { " + " ?s <http: + " ?s <http: + " } " + "}"; Model model = QueryUtils.getModelFromRepo(repo, sparqlQuery); assertThat( "All statements corresponding to sparql query should be loaded", model, hasSize(2) ); }
@Test public void modelGetter_givenSpecifiContexts_shouldLoadAllStatementsInRepo() { Model model = QueryUtils.getModelFromRepo(repo); assertThat( String.format("The in-memory store should contain %s statemtents", REPO_CONTEXTS_NR_STATEMENTS), model, hasSize(REPO_CONTEXTS_NR_STATEMENTS) ); }
@Test public void modelGetter_givenNoContext_shouldReturnAllStatementsInContexts() { Model model = QueryUtils.getModelFromRepo( repo, VF.createIRI(CONTEXT_A), VF.createIRI(CONTEXT_C) ); assertThat( String.format("The in-memory store should contain %s statemtents", REPO_CONTEXT_A_NR_STATEMENTS + REPO_CONTEXT_C_NR_STATEMENTS), model, hasSize(REPO_CONTEXT_A_NR_STATEMENTS + REPO_CONTEXT_C_NR_STATEMENTS) ); }
@Test public void modelGetter_givenSingleContext_shouldLoadAllStatementsOfContext() { Model model = QueryUtils.getModelFromRepo(repo, VF.createIRI(CONTEXT_A)); assertThat( String.format("The in-memory store should contain %s statemtents", REPO_CONTEXT_A_NR_STATEMENTS), model, hasSize(REPO_CONTEXT_A_NR_STATEMENTS) ); } |
### Question:
Offsets { public static Offset at(HorizontalOffset horizontal, VerticalOffset vertical) { return new InternalOffsets.OffsetImpl(horizontal, vertical); } static Offset at(HorizontalOffset horizontal, VerticalOffset vertical); static Offset at(String pos); }### Answer:
@Test public void testParseOk() { Offset rb1 = at("right bottom"); Offset rb2 = at("right+20% bottom+25%"); Offset rb3 = at("right-20% bottom-25%"); Offset rb4 = at("right+5px bottom+2px"); Offset rb5 = at("right-5px bottom-2px"); Offset tl1 = at("left top"); Offset tl2 = at("left+20% top+25%"); Offset tl3 = at("left-20% top-25%"); Offset tl4 = at("left+5px top+2px"); Offset tl5 = at("left-5px top-2px"); Offset cc1 = at("center center"); Offset cc2 = at("center+20% center+25%"); Offset cc3 = at("center-20% center-25%"); Offset cc4 = at("center+5px center+2px"); Offset cc5 = at("center-5px center-2px"); Offset ii1 = at("-inf -inf"); Offset ii2 = at("+inf -inf"); Offset ii3 = at("-inf +inf"); Rectangle r = new Rectangle(200, 100, 150, 160); assertThat(rb1.apply(r), equalTo(new Point(350, 260))); assertThat(rb2.apply(r), equalTo(new Point(380, 300))); assertThat(rb3.apply(r), equalTo(new Point(320, 220))); assertThat(rb4.apply(r), equalTo(new Point(355, 262))); assertThat(rb5.apply(r), equalTo(new Point(345, 258))); assertThat(tl1.apply(r), equalTo(new Point(200, 100))); assertThat(tl2.apply(r), equalTo(new Point(230, 140))); assertThat(tl3.apply(r), equalTo(new Point(170, 60))); assertThat(tl4.apply(r), equalTo(new Point(205, 102))); assertThat(tl5.apply(r), equalTo(new Point(195, 98))); assertThat(cc1.apply(r), equalTo(new Point(275, 180))); assertThat(cc2.apply(r), equalTo(new Point(305, 220))); assertThat(cc3.apply(r), equalTo(new Point(245, 140))); assertThat(cc4.apply(r), equalTo(new Point(280, 182))); assertThat(cc5.apply(r), equalTo(new Point(270, 178))); assertThat(ii1.apply(r), equalTo(new Point(Integer.MIN_VALUE, Integer.MIN_VALUE))); assertThat(ii2.apply(r), equalTo(new Point(Integer.MAX_VALUE, Integer.MIN_VALUE))); assertThat(ii3.apply(r), equalTo(new Point(Integer.MIN_VALUE, Integer.MAX_VALUE))); }
@Test(expected = ParseException.class) public void testParseVerticalFirstFail() { at("top right"); }
@Test(expected = ParseException.class) public void testParseInvalidFail() { at("right20px top"); }
@Test public void testToString() { assertThat(at(RIGHT.plus(20).percent(), BOTTOM.minus(25).pixels()).toString(), equalTo("right+20% bottom-25px")); } |
### Question:
HelloDocker { @GET public static String hello() { return "Hello world!"; } @GET static String hello(); static void main(String[] args); }### Answer:
@Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); } |
### Question:
MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public SharedCacheMode getSharedCacheMode() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testGetSharedCacheMode() { pui.getSharedCacheMode(); } |
### Question:
MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public ValidationMode getValidationMode() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testGetValidationMode() { pui.getValidationMode(); } |
### Question:
MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public String getPersistenceXMLSchemaVersion() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testGetPersistenceXMLSchemaVersion() { pui.getPersistenceXMLSchemaVersion(); } |
### Question:
MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public ClassLoader getClassLoader() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testGetClassLoader() { pui.getClassLoader(); } |
### Question:
MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public void addTransformer(final ClassTransformer transformer) { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testAddTransformer() { pui.addTransformer(null); } |
### Question:
MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public ClassLoader getNewTempClassLoader() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testGetNewTempClassLoader() { pui.getNewTempClassLoader(); } |
### Question:
Parser { private MinijaxCriteriaQuery<T> parseSelect() { consume(TokenType.KEYWORD_SELECT); query = cb.createQuery(resultType); while (getCurr().getTokenType() != TokenType.KEYWORD_FROM) { index++; } consume(TokenType.KEYWORD_FROM); final MinijaxEntityType<T> resultEntityType = cb.getMetamodel().entity(resultType); final String entityTypeName = consume(TokenType.SYMBOL).getValue(); if (!resultEntityType.getName().equals(entityTypeName)) { throw new PersistenceException( "Result type does not match entity type name (resultEntityType=" + resultEntityType.getName() + ", entityTypeName=" + entityTypeName + ")"); } root = query.from(resultType); final String entityTypeAlias = consume(TokenType.SYMBOL).getValue(); root.alias(entityTypeAlias); while (!eof()) { final Token curr = getCurr(); switch (curr.getTokenType()) { case KEYWORD_WHERE: parseWhere(); break; case KEYWORD_ORDER: parseOrderBy(); break; default: throw new PersistenceException("Unexpected token: " + curr); } } return query; } private Parser(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); static MinijaxCriteriaQuery<T> parse(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); }### Answer:
@Test public void testParseSelect() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE id = :id")); assertNotNull(query); } |
### Question:
Parser { public static <T> MinijaxCriteriaQuery<T> parse(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens) { return new Parser<>(cb, resultType, tokens).parse(); } private Parser(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); static MinijaxCriteriaQuery<T> parse(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); }### Answer:
@Test public void testParseSelectConjunction() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE id = :id AND name = :name")); assertNotNull(query); }
@Test public void testParseSelectDisjunction() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE id = :id OR name = :name")); assertNotNull(query); }
@Test public void testParseEqualsNamedVariable() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE w.name = :names")); assertNotNull(query); }
@Test public void testParseIsNull() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE w.name IS NULL")); assertNotNull(query); }
@Test public void testParseIsNotNull() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE w.name IS NOT NULL")); assertNotNull(query); }
@Test public void testParseIn() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE w.name IN('foo', 'bar')")); assertNotNull(query); }
@Test public void testParseInNamedVariable() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE w.name IN :names")); assertNotNull(query); }
@Test public void testParseOrderByAsc() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w ORDER BY w.name ASC")); assertNotNull(query); }
@Test public void testParseOrderByDesc() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w ORDER BY w.name DESC")); assertNotNull(query); } |
### Question:
Hello { @GET public static String hello() { return "Hello world!"; } @GET static String hello(); static void main(String[] args); }### Answer:
@Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); } |
### Question:
Parser { private void parseOrderBy() { consume(TokenType.KEYWORD_ORDER); consume(TokenType.KEYWORD_BY); final MinijaxPath<?> path = parsePath(); boolean ascending = true; if (index < tokens.size()) { final Token curr = getCurr(); if (curr.getTokenType() == TokenType.KEYWORD_ASC) { consume(TokenType.KEYWORD_ASC); } else if (curr.getTokenType() == TokenType.KEYWORD_DESC) { consume(TokenType.KEYWORD_DESC); ascending = false; } } query.orderBy(new MinijaxOrder(path, ascending)); } private Parser(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); static MinijaxCriteriaQuery<T> parse(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); }### Answer:
@Test public void testParseOrderBy() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w ORDER BY w.name")); assertNotNull(query); } |
### Question:
Tokenizer { public static List<Token> tokenize(final String str) { return new Tokenizer(str).tokenize(); } private Tokenizer(final String str); static List<Token> tokenize(final String str); }### Answer:
@Test public void testSelectByVariable() { final List<Token> tokens = Tokenizer.tokenize("SELECT w FROM Widget w WHERE id = :id"); assertNotNull(tokens); assertEquals(9, tokens.size()); final List<Token> expected = Arrays.asList( new Token(TokenType.KEYWORD_SELECT, "SELECT", 1, 1), new Token(TokenType.SYMBOL, "w", 1, 8), new Token(TokenType.KEYWORD_FROM, "FROM", 1, 10), new Token(TokenType.SYMBOL, "Widget", 1, 15), new Token(TokenType.SYMBOL, "w", 1, 22), new Token(TokenType.KEYWORD_WHERE, "WHERE", 1, 24), new Token(TokenType.SYMBOL, "id", 1, 30), new Token(TokenType.EQUALS, "=", 1, 33), new Token(TokenType.NAMED_PARAMETER, "id", 1, 35)); assertEquals(expected, tokens); }
@Test public void testSelectByNumber() { final List<Token> tokens = Tokenizer.tokenize("SELECT w FROM Widget w WHERE id = 123"); assertNotNull(tokens); assertEquals(9, tokens.size()); final List<Token> expected = Arrays.asList( new Token(TokenType.KEYWORD_SELECT, "SELECT", 1, 1), new Token(TokenType.SYMBOL, "w", 1, 8), new Token(TokenType.KEYWORD_FROM, "FROM", 1, 10), new Token(TokenType.SYMBOL, "Widget", 1, 15), new Token(TokenType.SYMBOL, "w", 1, 22), new Token(TokenType.KEYWORD_WHERE, "WHERE", 1, 24), new Token(TokenType.SYMBOL, "id", 1, 30), new Token(TokenType.EQUALS, "=", 1, 33), new Token(TokenType.NUMBER, "123", 1, 35)); assertEquals(expected, tokens); }
@Test public void testSelectByString() { final List<Token> tokens = Tokenizer.tokenize("SELECT w FROM Widget w WHERE id = 'xyz'"); assertNotNull(tokens); assertEquals(9, tokens.size()); final List<Token> expected = Arrays.asList( new Token(TokenType.KEYWORD_SELECT, "SELECT", 1, 1), new Token(TokenType.SYMBOL, "w", 1, 8), new Token(TokenType.KEYWORD_FROM, "FROM", 1, 10), new Token(TokenType.SYMBOL, "Widget", 1, 15), new Token(TokenType.SYMBOL, "w", 1, 22), new Token(TokenType.KEYWORD_WHERE, "WHERE", 1, 24), new Token(TokenType.SYMBOL, "id", 1, 30), new Token(TokenType.EQUALS, "=", 1, 33), new Token(TokenType.STRING, "xyz", 1, 35)); assertEquals(expected, tokens); } |
### Question:
App { @GET @Path("/") public static String hello() { return "Hello world!"; } @GET @Path("/") static String hello(); static void main(final String[] args); }### Answer:
@Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); } |
### Question:
MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public MinijaxEntityManager createEntityManager() { return new MinijaxEntityManager(this, metamodel, dialect, createConnection()); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer:
@Test(expected = UnsupportedOperationException.class) @SuppressWarnings("rawtypes") public void testCreateEntityManager1() { emf.createEntityManager((Map) null); }
@Test(expected = UnsupportedOperationException.class) public void testCreateEntityManager2() { emf.createEntityManager((SynchronizationType) null); }
@Test(expected = UnsupportedOperationException.class) @SuppressWarnings("rawtypes") public void testCreateEntityManager3() { emf.createEntityManager((SynchronizationType) null, (Map) null); } |
### Question:
MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public CriteriaBuilder getCriteriaBuilder() { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testGetCriteriaBuilder() { emf.getCriteriaBuilder(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.