method2testcases stringlengths 118 3.08k |
|---|
### Question:
PerfRuntimeOptions { public PerfRuntimeOptions addCucumberOptions(List<String> args) { for (String arg : args) { List<String> ca = Shellwords.parse(arg); int p = 0; boolean ispretty = false; for (int i = 0; i < ca.size(); i++) { if (ca.get(i).contentEquals("-p")) { p = i; } if (ca.get(i).contains("pretty")) { ca.remove(i); i--; ispretty = true; } try { if (ispretty && (ca.get(i).contentEquals("-p") || !isCucumberPlugin(ca.get(i)))) { ispretty = false; ca.remove(p); } } catch (Exception e) { } } cucumberOptions.addAll(ca); } return this; } PerfRuntimeOptions(); PerfRuntimeOptions(List<String> argv); List<String> getPluginsNames(); boolean isDryRun(); boolean isMonochrome(); boolean isStrict(); boolean isFailFast(); List<String> getPlanPaths(); List<Pattern> getNameFilters(); List<String> getTagFilters(); List<String> getCucumberOptions(); PerfRuntimeOptions addPlanPaths(List<String> planPaths); PerfRuntimeOptions addNameFilters(List<String> nameFilters); PerfRuntimeOptions addTagFilters(List<String> tagFilters); PerfRuntimeOptions addPlugins(List<String> plugins); void disableDisplay(); PerfRuntimeOptions addCucumberOptions(List<String> args); void setDryRun(boolean dryRun); void setStrict(boolean strict); void setMonochrome(boolean monochrome); void setFailFast(boolean failFast); static final String VERSION; static final String USAGE_RESOURCE; }### Answer:
@Test public void testAddCucumberOptions() { PerfRuntimeOptions pro = new PerfRuntimeOptions(); pro.addCucumberOptions(Arrays.asList(new String[] {"-p pretty", "-g steps","src/test/java/resources"})); assertEquals("-g",pro.getCucumberOptions().get(0)); } |
### Question:
PerfRuntimeOptions { public void setDryRun(boolean dryRun) { this.dryRun = dryRun; } PerfRuntimeOptions(); PerfRuntimeOptions(List<String> argv); List<String> getPluginsNames(); boolean isDryRun(); boolean isMonochrome(); boolean isStrict(); boolean isFailFast(); List<String> getPlanPaths(); List<Pattern> getNameFilters(); List<String> getTagFilters(); List<String> getCucumberOptions(); PerfRuntimeOptions addPlanPaths(List<String> planPaths); PerfRuntimeOptions addNameFilters(List<String> nameFilters); PerfRuntimeOptions addTagFilters(List<String> tagFilters); PerfRuntimeOptions addPlugins(List<String> plugins); void disableDisplay(); PerfRuntimeOptions addCucumberOptions(List<String> args); void setDryRun(boolean dryRun); void setStrict(boolean strict); void setMonochrome(boolean monochrome); void setFailFast(boolean failFast); static final String VERSION; static final String USAGE_RESOURCE; }### Answer:
@Test public void testSetDryRun() { PerfRuntimeOptions pro = new PerfRuntimeOptions(Arrays.asList(new String[] {"plans=src/test/java/resources","-p pretty","-g steps","src/test/java/resources","dryrun"})); assertTrue(pro.isDryRun()); } |
### Question:
PerfRuntimeOptions { public void setMonochrome(boolean monochrome) { this.monochrome = monochrome; } PerfRuntimeOptions(); PerfRuntimeOptions(List<String> argv); List<String> getPluginsNames(); boolean isDryRun(); boolean isMonochrome(); boolean isStrict(); boolean isFailFast(); List<String> getPlanPaths(); List<Pattern> getNameFilters(); List<String> getTagFilters(); List<String> getCucumberOptions(); PerfRuntimeOptions addPlanPaths(List<String> planPaths); PerfRuntimeOptions addNameFilters(List<String> nameFilters); PerfRuntimeOptions addTagFilters(List<String> tagFilters); PerfRuntimeOptions addPlugins(List<String> plugins); void disableDisplay(); PerfRuntimeOptions addCucumberOptions(List<String> args); void setDryRun(boolean dryRun); void setStrict(boolean strict); void setMonochrome(boolean monochrome); void setFailFast(boolean failFast); static final String VERSION; static final String USAGE_RESOURCE; }### Answer:
@Test public void testSetMonoChrome() { PerfRuntimeOptions pro = new PerfRuntimeOptions(Arrays.asList(new String[] {"plans=src/test/java/resources","-p pretty","-g steps","src/test/java/resources","monochrome"})); assertTrue(pro.isMonochrome()); } |
### Question:
PerfRuntimeOptions { public void setFailFast(boolean failFast) { this.failFast = failFast; } PerfRuntimeOptions(); PerfRuntimeOptions(List<String> argv); List<String> getPluginsNames(); boolean isDryRun(); boolean isMonochrome(); boolean isStrict(); boolean isFailFast(); List<String> getPlanPaths(); List<Pattern> getNameFilters(); List<String> getTagFilters(); List<String> getCucumberOptions(); PerfRuntimeOptions addPlanPaths(List<String> planPaths); PerfRuntimeOptions addNameFilters(List<String> nameFilters); PerfRuntimeOptions addTagFilters(List<String> tagFilters); PerfRuntimeOptions addPlugins(List<String> plugins); void disableDisplay(); PerfRuntimeOptions addCucumberOptions(List<String> args); void setDryRun(boolean dryRun); void setStrict(boolean strict); void setMonochrome(boolean monochrome); void setFailFast(boolean failFast); static final String VERSION; static final String USAGE_RESOURCE; }### Answer:
@Test public void testSetFailFast() { PerfRuntimeOptions pro = new PerfRuntimeOptions(Arrays.asList(new String[] {"plans=src/test/java/resources","-p pretty","-g steps","src/test/java/resources","failfast"})); assertTrue(pro.isFailFast()); } |
### Question:
PerfRuntimeOptions { public void setStrict(boolean strict) { this.strict = strict; } PerfRuntimeOptions(); PerfRuntimeOptions(List<String> argv); List<String> getPluginsNames(); boolean isDryRun(); boolean isMonochrome(); boolean isStrict(); boolean isFailFast(); List<String> getPlanPaths(); List<Pattern> getNameFilters(); List<String> getTagFilters(); List<String> getCucumberOptions(); PerfRuntimeOptions addPlanPaths(List<String> planPaths); PerfRuntimeOptions addNameFilters(List<String> nameFilters); PerfRuntimeOptions addTagFilters(List<String> tagFilters); PerfRuntimeOptions addPlugins(List<String> plugins); void disableDisplay(); PerfRuntimeOptions addCucumberOptions(List<String> args); void setDryRun(boolean dryRun); void setStrict(boolean strict); void setMonochrome(boolean monochrome); void setFailFast(boolean failFast); static final String VERSION; static final String USAGE_RESOURCE; }### Answer:
@Test public void testSetStrict() { PerfRuntimeOptions pro = new PerfRuntimeOptions(Arrays.asList(new String[] {"plans=src/test/java/resources","-p pretty","-g steps","src/test/java/resources","no-strict"})); assertFalse(pro.isStrict()); } |
### Question:
PerfRuntimeOptionsFactory { public PerfRuntimeOptions create() { List<String> args = buildArgsFromOptions(); return new PerfRuntimeOptions(args); } PerfRuntimeOptionsFactory(Class<?> clazz); PerfRuntimeOptions create(); }### Answer:
@Test public void testCreate() { PerfRuntimeOptionsFactory optf = new PerfRuntimeOptionsFactory(options1.class); PerfRuntimeOptions opt = optf.create(); assertEquals("not @tskip",opt.getTagFilters().get(0)); } |
### Question:
Stats { public Set<String> getStatisticTypes() { if (!statTypes.isEmpty()) return statTypes.keySet(); return null; } void putStatisticType(Stat stat); Stat getStatisticType(String key); Set<String> getStatisticTypes(); Set<String> getStatisticKeys(); LinkedHashMap<String,Double> getStatistics(String group, String scenario, String step); LinkedHashMap<String,Double> getStatistics(String group, String scenario); LinkedHashMap<String,Double> getStatistics(String groupOrKey); Double getStatistic(String name,String group, String scenario, String step); Double getStatistic(String name,String group, String scenario); Double getStatistic(String name,String groupOrKey); void putStatistic(String name, Double value, String group, String scenario, String step); void putStatistic(String name,Double value, String group, String scenario); void putStatistic(String name,Double value,String groupOrKey); void putKey(String group, String scenario, String step); void putKey(String group, String scenario); void putKey(String groupOrKey); void addStatistics(Stats stats); boolean isEmpty(); static String SEP; }### Answer:
@Test public void testGetStatisticTypes() { Stats stats = new Stats(); stats.putStatisticType(Stats.StatType.COUNT.type); assertEquals("cnt",stats.getStatisticTypes().toArray()[0]); } |
### Question:
Stats { public Set<String> getStatisticKeys() { if (!stats.isEmpty()) return stats.keySet(); return null; } void putStatisticType(Stat stat); Stat getStatisticType(String key); Set<String> getStatisticTypes(); Set<String> getStatisticKeys(); LinkedHashMap<String,Double> getStatistics(String group, String scenario, String step); LinkedHashMap<String,Double> getStatistics(String group, String scenario); LinkedHashMap<String,Double> getStatistics(String groupOrKey); Double getStatistic(String name,String group, String scenario, String step); Double getStatistic(String name,String group, String scenario); Double getStatistic(String name,String groupOrKey); void putStatistic(String name, Double value, String group, String scenario, String step); void putStatistic(String name,Double value, String group, String scenario); void putStatistic(String name,Double value,String groupOrKey); void putKey(String group, String scenario, String step); void putKey(String group, String scenario); void putKey(String groupOrKey); void addStatistics(Stats stats); boolean isEmpty(); static String SEP; }### Answer:
@Test public void testGetStatisticKeys() { Stats stats = new Stats(); stats.putStatistic("avg", 1.0,"grp1"); stats.putStatistic("cnt", 2.0,"grp2"); String[] types = new String[] {"grp1","grp2"}; for (String key : stats.getStatisticKeys()) { boolean found = false; for (String type : types) { if (type.equalsIgnoreCase(key)) found = true; } assertTrue(found); } } |
### Question:
Stats { public LinkedHashMap<String,Double> getStatistics(String group, String scenario, String step) { return stats.get(group+SEP+scenario+SEP+step); } void putStatisticType(Stat stat); Stat getStatisticType(String key); Set<String> getStatisticTypes(); Set<String> getStatisticKeys(); LinkedHashMap<String,Double> getStatistics(String group, String scenario, String step); LinkedHashMap<String,Double> getStatistics(String group, String scenario); LinkedHashMap<String,Double> getStatistics(String groupOrKey); Double getStatistic(String name,String group, String scenario, String step); Double getStatistic(String name,String group, String scenario); Double getStatistic(String name,String groupOrKey); void putStatistic(String name, Double value, String group, String scenario, String step); void putStatistic(String name,Double value, String group, String scenario); void putStatistic(String name,Double value,String groupOrKey); void putKey(String group, String scenario, String step); void putKey(String group, String scenario); void putKey(String groupOrKey); void addStatistics(Stats stats); boolean isEmpty(); static String SEP; }### Answer:
@Test public void testGetStatistics() { Stats stats = new Stats(); stats.putStatistic("avg", 1.0,"grp","scn","stp"); stats.putStatistic("cnt", 2.0,"grp","scn","stp"); LinkedHashMap<String,Double> result =stats.getStatistics("grp", "scn", "stp"); int i = 0; for (Entry<String, Double> set : result.entrySet()) { if (i==0) assertEquals("avg",set.getKey()); else assertEquals("cnt",set.getKey()); i++; } } |
### Question:
Stats { public Double getStatistic(String name,String group, String scenario, String step) { LinkedHashMap<String,Double> s = stats.get(group+SEP+scenario+SEP+step); return s!=null?s.get(name):null; } void putStatisticType(Stat stat); Stat getStatisticType(String key); Set<String> getStatisticTypes(); Set<String> getStatisticKeys(); LinkedHashMap<String,Double> getStatistics(String group, String scenario, String step); LinkedHashMap<String,Double> getStatistics(String group, String scenario); LinkedHashMap<String,Double> getStatistics(String groupOrKey); Double getStatistic(String name,String group, String scenario, String step); Double getStatistic(String name,String group, String scenario); Double getStatistic(String name,String groupOrKey); void putStatistic(String name, Double value, String group, String scenario, String step); void putStatistic(String name,Double value, String group, String scenario); void putStatistic(String name,Double value,String groupOrKey); void putKey(String group, String scenario, String step); void putKey(String group, String scenario); void putKey(String groupOrKey); void addStatistics(Stats stats); boolean isEmpty(); static String SEP; }### Answer:
@Test public void testGetStatistic() { Stats stats = new Stats(); stats.putStatistic("avg", 1.0,"grp","scn","stp"); stats.putStatistic("cnt", 2.0,"grp","scn","stp"); assertEquals(1.0,stats.getStatistic("avg","grp","scn","stp"),0.1); } |
### Question:
Stats { public void putKey(String group, String scenario, String step) { if (!this.stats.containsKey(group+SEP+scenario+SEP+step)) { this.stats.put(group+SEP+scenario+SEP+step,this.getNewMap()); } } void putStatisticType(Stat stat); Stat getStatisticType(String key); Set<String> getStatisticTypes(); Set<String> getStatisticKeys(); LinkedHashMap<String,Double> getStatistics(String group, String scenario, String step); LinkedHashMap<String,Double> getStatistics(String group, String scenario); LinkedHashMap<String,Double> getStatistics(String groupOrKey); Double getStatistic(String name,String group, String scenario, String step); Double getStatistic(String name,String group, String scenario); Double getStatistic(String name,String groupOrKey); void putStatistic(String name, Double value, String group, String scenario, String step); void putStatistic(String name,Double value, String group, String scenario); void putStatistic(String name,Double value,String groupOrKey); void putKey(String group, String scenario, String step); void putKey(String group, String scenario); void putKey(String groupOrKey); void addStatistics(Stats stats); boolean isEmpty(); static String SEP; }### Answer:
@Test public void testPutKey() { Stats stats = new Stats(); stats.putStatisticType(Stats.StatType.PASSED.type); stats.putStatisticType(Stats.StatType.FAILED.type); stats.putKey("grp","scn"); LinkedHashMap<String,Double> result =stats.getStatistics("grp", "scn"); int i = 0; for (Entry<String, Double> set : result.entrySet()) { if (i==0) assertEquals("pass",set.getKey()); else assertEquals("fail",set.getKey()); i++; } } |
### Question:
Stats { public boolean isEmpty() { return this.stats.isEmpty(); } void putStatisticType(Stat stat); Stat getStatisticType(String key); Set<String> getStatisticTypes(); Set<String> getStatisticKeys(); LinkedHashMap<String,Double> getStatistics(String group, String scenario, String step); LinkedHashMap<String,Double> getStatistics(String group, String scenario); LinkedHashMap<String,Double> getStatistics(String groupOrKey); Double getStatistic(String name,String group, String scenario, String step); Double getStatistic(String name,String group, String scenario); Double getStatistic(String name,String groupOrKey); void putStatistic(String name, Double value, String group, String scenario, String step); void putStatistic(String name,Double value, String group, String scenario); void putStatistic(String name,Double value,String groupOrKey); void putKey(String group, String scenario, String step); void putKey(String group, String scenario); void putKey(String groupOrKey); void addStatistics(Stats stats); boolean isEmpty(); static String SEP; }### Answer:
@Test public void testIsEmpty() { Stats stats = new Stats(); stats.putStatisticType(Stats.StatType.PASSED.type); stats.putStatisticType(Stats.StatType.FAILED.type); stats.putKey("grp","scn"); assertFalse(stats.isEmpty()); } |
### Question:
DefaultStatistics { public static Stats getDefaultStats(boolean isStrict) { Stats stats = new Stats(); stats.putStatisticType(Stats.StatType.COUNT.type); if(!isStrict) { stats.putStatisticType(Stats.StatType.PASSED.type); stats.putStatisticType(Stats.StatType.FAILED.type); } stats.putStatisticType(Stats.StatType.AVERAGE.type); stats.putStatisticType(Stats.StatType.MINIMUM.type); stats.putStatisticType(Stats.StatType.MAXIMUM.type); stats.putStatisticType(Stats.StatType.CONCURRENCY.type); return stats; } DefaultStatistics(BaseResult simulation,HashMap<String,List<GroupResult>> results); Statistics getStatistics(); HashMap<String,List<Long>> getSortedResults(); Stats getStats(boolean isStrict); Stats getStats(boolean isStrict,LocalDateTime startPeriod,LocalDateTime endPeriod); HashMap<String,HashMap<String,StepErrors>> getErrors(); static Stats getDefaultStats(boolean isStrict); }### Answer:
@Test public void testGetDefaultStats() { Stats s = DefaultStatistics.getDefaultStats(true); assertEquals("avg",s.getStatisticType("avg").getKey()); assertEquals("min",s.getStatisticType("min").getKey()); assertEquals("max",s.getStatisticType("max").getKey()); assertEquals("cnt",s.getStatisticType("cnt").getKey()); assertEquals("cncrnt",s.getStatisticType("cncrnt").getKey()); assertEquals(null,s.getStatisticType("fail")); s = DefaultStatistics.getDefaultStats(false); assertEquals("avg",s.getStatisticType("avg").getKey()); assertEquals("min",s.getStatisticType("min").getKey()); assertEquals("max",s.getStatisticType("max").getKey()); assertEquals("cnt",s.getStatisticType("cnt").getKey()); assertEquals("cncrnt",s.getStatisticType("cncrnt").getKey()); assertEquals("pass",s.getStatisticType("pass").getKey()); assertEquals("fail",s.getStatisticType("fail").getKey()); } |
### Question:
PlanParser { public PerfPlan parseResource(Resource resource) { requireNonNull(resource); URI uri = resource.getUri(); String source = read(resource); ServiceLoader<cucumber.perf.salad.PlanParser> services =ServiceLoader.load(cucumber.perf.salad.PlanParser.class); Iterator<cucumber.perf.salad.PlanParser> iterator = services.iterator(); List<cucumber.perf.salad.PlanParser> parser = new ArrayList<>(); while (iterator.hasNext()) { parser.add(iterator.next()); } Comparator<cucumber.perf.salad.PlanParser> version = comparing(cucumber.perf.salad.PlanParser::version); return Collections.max(parser, version).parse(uri, source, idGenerator); } PlanParser(Supplier<UUID> idGenerator); PerfPlan parseResource(Resource resource); }### Answer:
@Test public void testParseResource() { PlanParser p = new PlanParser(UUID::randomUUID); URI uri = URI.create("src/test/java/resources/test.plan"); Resource r = new UriResource(Paths.get(uri.getPath())); PerfPlan pp = p.parseResource(r); assertEquals("simulation 1", pp.getSaladPlan().getPlan().getChildren().get(0).getName()); } |
### Question:
PlanIdentifier { public static URI parse(String planIdentifier) { return parse(PlanPath.parse(planIdentifier)); } private PlanIdentifier(); static URI parse(String planIdentifier); static URI parse(URI planIdentifier); static boolean isPlan(URI planIdentifier); static boolean isPlan(Path path); }### Answer:
@Test public void testParseString() { assertTrue(PlanIdentifier.parse("baba.plan").toString().contains("/Cucumber-Perf/baba.plan")); }
@Test public void testParseClassPath() { URI uri = PlanIdentifier.parse("classpath:/path/to/file.plan"); assertEquals(uri.getScheme(), "classpath"); assertEquals(uri.getSchemeSpecificPart(), "/path/to/file.plan"); }
@Test public void testParseURI() { assertEquals("baba.plan",PlanIdentifier.parse(URI.create("baba.plan")).toString()); try { PlanIdentifier.parse(URI.create("baba.p")); fail("Did not fail bogus plan URI"); } catch (Exception e) { } } |
### Question:
LatencyFaultToleranceImpl implements LatencyFaultTolerance<String> { @Override public String pickOneAtLeast() { final Enumeration<FaultItem> elements = this.faultItemTable.elements(); List<FaultItem> tmpList = new LinkedList<>(); while (elements.hasMoreElements()) { final FaultItem faultItem = elements.nextElement(); tmpList.add(faultItem); } if (!tmpList.isEmpty()) { Collections.shuffle(tmpList); Collections.sort(tmpList); final int half = tmpList.size() / 2; if (half <= 0) { return tmpList.get(0).getName(); } else { final int i = this.whichItemWorst.getAndIncrement() % half; return tmpList.get(i).getName(); } } return null; } @Override void updateFaultItem(final String name, final long currentLatency, final long notAvailableDuration); @Override boolean isAvailable(final String name); @Override void remove(final String name); @Override String pickOneAtLeast(); @Override String toString(); }### Answer:
@Test public void testPickOneAtLeast() throws Exception { latencyFaultTolerance.updateFaultItem(brokerName, 1000, 3000); assertThat(latencyFaultTolerance.pickOneAtLeast()).isEqualTo(brokerName); latencyFaultTolerance.updateFaultItem(anotherBrokerName, 1001, 3000); assertThat(latencyFaultTolerance.pickOneAtLeast()).isEqualTo(brokerName); } |
### Question:
RouteInfoManager { public byte[] getAllClusterInfo() { ClusterInfo clusterInfoSerializeWrapper = new ClusterInfo(); clusterInfoSerializeWrapper.setBrokerAddrTable(this.brokerAddrTable); clusterInfoSerializeWrapper.setClusterAddrTable(this.clusterAddrTable); return clusterInfoSerializeWrapper.encode(); } RouteInfoManager(); byte[] getAllClusterInfo(); void deleteTopic(final String topic); byte[] getAllTopicList(); RegisterBrokerResult registerBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId,
final String haServerAddr,
final TopicConfigSerializeWrapper topicConfigWrapper,
final List<String> filterServerList,
final Channel channel); int wipeWritePermOfBrokerByLock(final String brokerName); @SuppressWarnings("SpellCheckingInspection") void unregisterBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId); TopicRouteData pickupTopicRouteData(final String topic); void scanNotActiveBroker(); void onChannelDestroy(String remoteAddr, Channel channel); void printAllPeriodically(); byte[] getSystemTopicList(); byte[] getTopicsByCluster(String cluster); byte[] getUnitTopics(); byte[] getHasUnitSubTopicList(); byte[] getHasUnitSubUnUnitTopicList(); }### Answer:
@Test public void testGetAllClusterInfo() { byte[] clusterInfo = routeInfoManager.getAllClusterInfo(); assertThat(clusterInfo).isNotNull(); } |
### Question:
RouteInfoManager { public byte[] getAllTopicList() { TopicList topicList = new TopicList(); try { try { this.lock.readLock().lockInterruptibly(); topicList.getTopicList().addAll(this.topicQueueTable.keySet()); } finally { this.lock.readLock().unlock(); } } catch (Exception e) { log.error("getAllTopicList Exception", e); } return topicList.encode(); } RouteInfoManager(); byte[] getAllClusterInfo(); void deleteTopic(final String topic); byte[] getAllTopicList(); RegisterBrokerResult registerBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId,
final String haServerAddr,
final TopicConfigSerializeWrapper topicConfigWrapper,
final List<String> filterServerList,
final Channel channel); int wipeWritePermOfBrokerByLock(final String brokerName); @SuppressWarnings("SpellCheckingInspection") void unregisterBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId); TopicRouteData pickupTopicRouteData(final String topic); void scanNotActiveBroker(); void onChannelDestroy(String remoteAddr, Channel channel); void printAllPeriodically(); byte[] getSystemTopicList(); byte[] getTopicsByCluster(String cluster); byte[] getUnitTopics(); byte[] getHasUnitSubTopicList(); byte[] getHasUnitSubUnUnitTopicList(); }### Answer:
@Test public void testGetAllTopicList() { byte[] topicInfo = routeInfoManager.getAllTopicList(); Assert.assertTrue(topicInfo != null); assertThat(topicInfo).isNotNull(); } |
### Question:
RouteInfoManager { public int wipeWritePermOfBrokerByLock(final String brokerName) { try { try { this.lock.writeLock().lockInterruptibly(); return wipeWritePermOfBroker(brokerName); } finally { this.lock.writeLock().unlock(); } } catch (Exception e) { log.error("wipeWritePermOfBrokerByLock Exception", e); } return 0; } RouteInfoManager(); byte[] getAllClusterInfo(); void deleteTopic(final String topic); byte[] getAllTopicList(); RegisterBrokerResult registerBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId,
final String haServerAddr,
final TopicConfigSerializeWrapper topicConfigWrapper,
final List<String> filterServerList,
final Channel channel); int wipeWritePermOfBrokerByLock(final String brokerName); @SuppressWarnings("SpellCheckingInspection") void unregisterBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId); TopicRouteData pickupTopicRouteData(final String topic); void scanNotActiveBroker(); void onChannelDestroy(String remoteAddr, Channel channel); void printAllPeriodically(); byte[] getSystemTopicList(); byte[] getTopicsByCluster(String cluster); byte[] getUnitTopics(); byte[] getHasUnitSubTopicList(); byte[] getHasUnitSubUnUnitTopicList(); }### Answer:
@Test public void testWipeWritePermOfBrokerByLock() { int result = routeInfoManager.wipeWritePermOfBrokerByLock("default-broker"); assertThat(result).isEqualTo(0); } |
### Question:
RouteInfoManager { public byte[] getUnitTopics() { TopicList topicList = new TopicList(); try { try { this.lock.readLock().lockInterruptibly(); Iterator<Entry<String, List<QueueData>>> topicTableIt = this.topicQueueTable.entrySet().iterator(); while (topicTableIt.hasNext()) { Entry<String, List<QueueData>> topicEntry = topicTableIt.next(); String topic = topicEntry.getKey(); List<QueueData> queueDatas = topicEntry.getValue(); if (queueDatas != null && queueDatas.size() > 0 && TopicSysFlag.hasUnitFlag(queueDatas.get(0).getTopicSynFlag())) { topicList.getTopicList().add(topic); } } } finally { this.lock.readLock().unlock(); } } catch (Exception e) { log.error("getAllTopicList Exception", e); } return topicList.encode(); } RouteInfoManager(); byte[] getAllClusterInfo(); void deleteTopic(final String topic); byte[] getAllTopicList(); RegisterBrokerResult registerBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId,
final String haServerAddr,
final TopicConfigSerializeWrapper topicConfigWrapper,
final List<String> filterServerList,
final Channel channel); int wipeWritePermOfBrokerByLock(final String brokerName); @SuppressWarnings("SpellCheckingInspection") void unregisterBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId); TopicRouteData pickupTopicRouteData(final String topic); void scanNotActiveBroker(); void onChannelDestroy(String remoteAddr, Channel channel); void printAllPeriodically(); byte[] getSystemTopicList(); byte[] getTopicsByCluster(String cluster); byte[] getUnitTopics(); byte[] getHasUnitSubTopicList(); byte[] getHasUnitSubUnUnitTopicList(); }### Answer:
@Test public void testGetUnitTopics() { byte[] topicList = routeInfoManager.getUnitTopics(); assertThat(topicList).isNotNull(); } |
### Question:
RouteInfoManager { public byte[] getHasUnitSubTopicList() { TopicList topicList = new TopicList(); try { try { this.lock.readLock().lockInterruptibly(); Iterator<Entry<String, List<QueueData>>> topicTableIt = this.topicQueueTable.entrySet().iterator(); while (topicTableIt.hasNext()) { Entry<String, List<QueueData>> topicEntry = topicTableIt.next(); String topic = topicEntry.getKey(); List<QueueData> queueDatas = topicEntry.getValue(); if (queueDatas != null && queueDatas.size() > 0 && TopicSysFlag.hasUnitSubFlag(queueDatas.get(0).getTopicSynFlag())) { topicList.getTopicList().add(topic); } } } finally { this.lock.readLock().unlock(); } } catch (Exception e) { log.error("getAllTopicList Exception", e); } return topicList.encode(); } RouteInfoManager(); byte[] getAllClusterInfo(); void deleteTopic(final String topic); byte[] getAllTopicList(); RegisterBrokerResult registerBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId,
final String haServerAddr,
final TopicConfigSerializeWrapper topicConfigWrapper,
final List<String> filterServerList,
final Channel channel); int wipeWritePermOfBrokerByLock(final String brokerName); @SuppressWarnings("SpellCheckingInspection") void unregisterBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId); TopicRouteData pickupTopicRouteData(final String topic); void scanNotActiveBroker(); void onChannelDestroy(String remoteAddr, Channel channel); void printAllPeriodically(); byte[] getSystemTopicList(); byte[] getTopicsByCluster(String cluster); byte[] getUnitTopics(); byte[] getHasUnitSubTopicList(); byte[] getHasUnitSubUnUnitTopicList(); }### Answer:
@Test public void testGetHasUnitSubTopicList() { byte[] topicList = routeInfoManager.getHasUnitSubTopicList(); assertThat(topicList).isNotNull(); } |
### Question:
ProducerManager { public void doChannelCloseEvent(final String remoteAddr, final Channel channel) { if (channel != null) { try { if (this.groupChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { for (final Map.Entry<String, HashMap<Channel, ClientChannelInfo>> entry : this.groupChannelTable.entrySet()) { final String group = entry.getKey(); final HashMap<Channel, ClientChannelInfo> clientChannelInfoTable = entry.getValue(); final ClientChannelInfo clientChannelInfo = clientChannelInfoTable.remove(channel); if (clientChannelInfo != null) { log.info( "NETTY EVENT: remove channel[{}][{}] from ProducerManager groupChannelTable, producer group: {}", clientChannelInfo.toString(), remoteAddr, group); } } } finally { this.groupChannelLock.unlock(); } } else { log.warn("ProducerManager doChannelCloseEvent lock timeout"); } } catch (InterruptedException e) { log.error("", e); } } } ProducerManager(); HashMap<String, HashMap<Channel, ClientChannelInfo>> getGroupChannelTable(); void scanNotActiveChannel(); void doChannelCloseEvent(final String remoteAddr, final Channel channel); void registerProducer(final String group, final ClientChannelInfo clientChannelInfo); void unregisterProducer(final String group, final ClientChannelInfo clientChannelInfo); }### Answer:
@Test public void doChannelCloseEvent() throws Exception { producerManager.registerProducer(group, clientInfo); assertThat(producerManager.getGroupChannelTable().get(group).get(channel)).isNotNull(); producerManager.doChannelCloseEvent("127.0.0.1", channel); assertThat(producerManager.getGroupChannelTable().get(group).get(channel)).isNull(); } |
### Question:
ExcelRequirementsReader implements RequirementsReader { @Override public DrawRequirements read(final String name, final InputStream stream) { List<List<String>> content = readContent(name, stream); List<Person> participants = content.stream() .map(l -> new Person(l.get(0), role(name, l))) .collect(toList()); Map<String, Person> participantMap = participantMap(name, participants); List<Restriction> restrictions = restrictions(name, participantMap, content); return new DrawRequirements(participants, restrictions); } @Override DrawRequirements read(final String name, final InputStream stream); }### Answer:
@Test public void loadRequirements() throws Exception { try (InputStream stream = ExcelRequirementsReaderTest.class.getResourceAsStream(SPREADSHEET_XLS)) { DrawRequirements requirements = target.read(SPREADSHEET_XLS, stream); assertEquals(TestRequirementsTool.REQUIREMENTS, requirements); } } |
### Question:
MatcherContext { public Person lookupReceiver(final int index) { return receivers.get(index); } MatcherContext(final List<Person> receivers, final Set<GiverAssignment> restrictions); OptionalInt allocateNextReceiver(final int previousIndex); Person lookupReceiver(final int index); Set<Person> getRemainingReceivers(); boolean isPossibleMatch(final GiverAssignment pair); static final int NO_RECEIVER_ALLOCATED; }### Answer:
@Test public void testLookupReceiver() { assertAll( () -> assertEquals(PERSON_1, target.lookupReceiver(0)), () -> assertEquals(PERSON_2, target.lookupReceiver(1)), () -> assertEquals(PERSON_3, target.lookupReceiver(2)) ); } |
### Question:
MatcherContext { public boolean isPossibleMatch(final GiverAssignment pair) { return !restrictions.contains(pair); } MatcherContext(final List<Person> receivers, final Set<GiverAssignment> restrictions); OptionalInt allocateNextReceiver(final int previousIndex); Person lookupReceiver(final int index); Set<Person> getRemainingReceivers(); boolean isPossibleMatch(final GiverAssignment pair); static final int NO_RECEIVER_ALLOCATED; }### Answer:
@Test public void testIsPossibleMatch() { assertAll( () -> assertFalse(target.isPossibleMatch(ASSIGNMENT_1_2)), () -> assertTrue(target.isPossibleMatch(ASSIGNMENT_1_3)) ); } |
### Question:
MatcherContext { public Set<Person> getRemainingReceivers() { return IntStream.range(0, satisfiedReceivers.length) .filter(i -> !satisfiedReceivers[i]) .mapToObj(receivers::get) .collect(Collectors.toUnmodifiableSet()); } MatcherContext(final List<Person> receivers, final Set<GiverAssignment> restrictions); OptionalInt allocateNextReceiver(final int previousIndex); Person lookupReceiver(final int index); Set<Person> getRemainingReceivers(); boolean isPossibleMatch(final GiverAssignment pair); static final int NO_RECEIVER_ALLOCATED; }### Answer:
@Test public void testInitialReceivers() { assertEquals(Set.of(PERSON_1, PERSON_2, PERSON_3), target.getRemainingReceivers()); } |
### Question:
MatcherFrame { public boolean selectMatch() { OptionalInt receiver = context.allocateNextReceiver(receiverIndex); while (receiver.isPresent()) { receiverIndex = receiver.getAsInt(); Person rhs = context.lookupReceiver(receiverIndex); if (!lhs.equals(rhs)) { pair = new GiverAssignment(lhs, rhs); if (context.isPossibleMatch(pair)) { return true; } } receiver = context.allocateNextReceiver(receiverIndex); } pair = null; return false; } MatcherFrame(final MatcherContext context, final Person lhs); boolean selectMatch(); GiverAssignment getPair(); }### Answer:
@Test public void testEmpty() { MatcherContext context = new MatcherContext(RECEIVERS_NONE, RESTRICTIONS_EMPTY); MatcherFrame target = new MatcherFrame(context, PERSON_1); boolean isMatch = target.selectMatch(); assertAll( () -> assertFalse(isMatch), () -> assertEquals(Set.of(), context.getRemainingReceivers()), () -> assertThrows(IllegalStateException.class, target::getPair) ); }
@Test public void testThirdSelectMatch() { MatcherContext context = new MatcherContext(RECEIVERS_ALL, RESTRICTIONS_EMPTY); MatcherFrame target = new MatcherFrame(context, PERSON_1); target.selectMatch(); target.selectMatch(); boolean isMatch = target.selectMatch(); assertAll( () -> assertFalse(isMatch), () -> assertEquals(Set.of(PERSON_1, PERSON_2, PERSON_3), context.getRemainingReceivers()), () -> assertThrows(IllegalStateException.class, target::getPair) ); } |
### Question:
PdfGiverAssignmentWriter implements GiverAssignmentWriter { @Override public void writeGiverAssignment(final String name, final GiverAssignment assignment, final OutputStream out, final String password) { try (Document document = new Document(PageSize.A5)) { handleMetaData(out, password, document); header.setAlignment(Element.ALIGN_CENTER); header.scalePercent(IMAGE_SCALE_PERCENTAGE); document.open(); document.add(header); addParagraph(document, assignment.getFrom().getName(), FONT_SIZE_MAIN, Font.BOLDITALIC, Color.BLACK); addParagraph(document, phrase, FONT_SIZE_MAIN, Font.ITALIC, Color.BLACK); addParagraph(document, assignment.getTo().getName(), FONT_SIZE_GIFT_RECEIVER, Font.BOLDITALIC, Color.RED); } catch (Exception e) { throw new SantaException(String.format("Unable to create PDF '%s'", name), e); } } PdfGiverAssignmentWriter(final I18nBundleProvider provider); @Override void writeGiverAssignment(final String name, final GiverAssignment assignment, final OutputStream out, final String password); @Override String getFormatSuffix(); static final String FORMAT_SUFFIX; }### Answer:
@Test public void testWrite() throws Exception { try (OutputStream out = Files.newOutputStream(file)) { GiverAssignment assignment = WriterTestTool.assignment("Albert", "Beryl"); target.writeGiverAssignment(file.toString(), assignment, out, "secret"); assertTrue(Files.size(file) > 0, "Output"); } } |
### Question:
SessionModelTool { public SessionModel buildGuiModel(final SessionState state, final Path file) { SessionModel model = buildGuiModel(state.getParticipants()); model.setDrawName(state.getDrawName()); model.setPassword(state.getPassword()); model.setSessionFile(file); return model; } @Inject SessionModelTool(final I18nManager i18nManager); SessionModel buildGuiModel(final SessionState state, final Path file); SessionModel buildGuiModel(final List<ParticipantState> participants); SessionState buildFileModel(final SessionModel model); }### Answer:
@Test public void testBuildGuiModel() { SessionState input = buildFullState(); SessionModel result = target.buildGuiModel(input, FILE); assertAll( () -> assertTrue(result.isChangesSaved()), () -> assertEquals(DRAW_NAME_1, result.getDrawName()), () -> assertEquals(PASSWORD, result.getPassword()), () -> assertEquals(FILE, result.getSessionFile()), () -> { List<ParticipantModel> participants = result.getParticipants(); assertAll( () -> assertEquals(PARTICIPANT_COUNT + 1, participants.size()), () -> validate(albert, participants.get(INDEX_ALBERT)), () -> validate(beryl, participants.get(INDEX_BERYL)), () -> validate(carla, participants.get(INDEX_CARLA)), () -> validate(david, participants.get(INDEX_DAVID)), () -> validate(edith, participants.get(INDEX_EDITH)), () -> validate(fred, participants.get(INDEX_FRED)), () -> validate(gina, participants.get(INDEX_GINA)), () -> validate(harry, participants.get(INDEX_HARRY)), () -> validate(iris, participants.get(INDEX_IRIS)), () -> validate(john, participants.get(INDEX_JOHN)), () -> validate(kate, participants.get(INDEX_KATE)), () -> validate(placeholder, participants.get(PARTICIPANT_COUNT)) ); } ); } |
### Question:
SessionModelTool { public SessionState buildFileModel(final SessionModel model) { SessionState state = new SessionState(); List<ParticipantState> participants = model.getParticipants().stream() .filter(p -> !p.isPlaceholder()) .map(this::buildParticipantState) .collect(toList()); state.setParticipants(participants); state.setDrawName(model.getDrawName()); state.setPassword(model.getPassword()); return state; } @Inject SessionModelTool(final I18nManager i18nManager); SessionModel buildGuiModel(final SessionState state, final Path file); SessionModel buildGuiModel(final List<ParticipantState> participants); SessionState buildFileModel(final SessionModel model); }### Answer:
@Test public void testBuildFileModel() { List<ParticipantModel> participants = List.of(albert, beryl, carla, david, edith, fred, gina, harry, iris, john, kate); SessionModel input = new SessionModel(i18nManager, participants); input.setDrawName(DRAW_NAME_1); input.setPassword(PASSWORD); SessionState result = target.buildFileModel(input); assertEquals(buildFullState(), result); } |
### Question:
ProgressState { public boolean isComplete() { return currentPercent.get() == MAX_PERCENT; } ProgressState(final ProgressPoint... sequence); ProgressState(final List<ProgressPoint> sequence); int tick(final int size); boolean isComplete(); }### Answer:
@Test public void testEmpty() { target = new ProgressState(); assertFalse(target.isComplete()); validateIncrement(100, 0, 0); validateNoIncrement(100, 0); assertTrue(target.isComplete()); }
@Test public void testPointAtStart() { target = new ProgressState(new ProgressPoint(0, 1)); assertFalse(target.isComplete()); validateNoIncrement(0, 0); validateIncrement(100, 0, 1); validateNoIncrement(100, 1); assertTrue(target.isComplete()); }
@Test public void testPointAtStartEnd() { target = new ProgressState(new ProgressPoint(100, 1)); assertFalse(target.isComplete()); validateIncrement(99, 0, 0); validateNoIncrement(99, 0); validateIncrement(1, 99, 1); validateNoIncrement(100, 1); assertTrue(target.isComplete()); }
@Test public void testThreePoints() { target = new ProgressState( new ProgressPoint(10, 1), new ProgressPoint(20, 2), new ProgressPoint(30, 3)); assertFalse(target.isComplete()); validateIncrement(9, 0, 0); validateNoIncrement(9, 0); validateIncrement(10, 9, 1); validateNoIncrement(19, 1); validateIncrement(10, 19, 2); validateNoIncrement(29, 2); validateIncrement(71, 29, 3); validateNoIncrement(100, 0); assertTrue(target.isComplete()); } |
### Question:
DrawValidationTool { public static void validate(final DrawRequirements requirements, final DrawSelection selection) { validateRestrictions(requirements, selection); validateRecipients(requirements, selection); validateGivers(requirements, selection); } private DrawValidationTool(); static void validate(final DrawRequirements requirements, final DrawSelection selection); }### Answer:
@Test public void testAcceptedSelection() { DrawSelection selection = selection(giver(PERSON_3, PERSON_2), giver(PERSON_2, PERSON_1), giver(PERSON_1, PERSON_3)); DrawValidationTool.validate(REQUIREMENTS, selection); }
@Test public void testSimpleGiveAndReceive() { DrawSelection selection = selection(giver(GIVER_ONLY_1, RECEIVER_ONLY_1)); DrawValidationTool.validate(requirements(GIVER_ONLY_1, RECEIVER_ONLY_1), selection); } |
### Question:
ExecutableLogTool { public static void logStartup() { LOG.info("Application startup"); LOG.info("Santulator version: {}", BuildInfo.version()); } private ExecutableLogTool(); static void logSystemDetails(); static void logShutdown(); static void logStartup(); static void logError(final Throwable e); }### Answer:
@Test public void testLogStartup() { validate(ExecutableLogTool::logStartup); } |
### Question:
ExecutableLogTool { public static void logError(final Throwable e) { LOG.error("Application error", e); } private ExecutableLogTool(); static void logSystemDetails(); static void logShutdown(); static void logStartup(); static void logError(final Throwable e); }### Answer:
@Test public void testLogError() { validate(() -> ExecutableLogTool.logError(new SantaException("Test"))); }
@Test public void testLogError() { validate(() -> ExecutableLogTool.logError(new VocabHunterException("Test"))); } |
### Question:
FileChoice { public Path getFile() { return file; } FileChoice(final Path file, final FileFormatType type); Path getFile(); FileFormatType getType(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetFile() { assertEquals(FILE_1, PRIMARY.getFile()); }
@Test public void testGetFile() { assertEquals(FILE, PRIMARY.getFile()); } |
### Question:
FileChoice { public FileFormatType getType() { return type; } FileChoice(final Path file, final FileFormatType type); Path getFile(); FileFormatType getType(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetType() { assertEquals(FileFormatType.SESSION, PRIMARY.getType()); }
@Test public void testGetType() { assertEquals(PRIMARY_TYPE, PRIMARY.getType()); } |
### Question:
FileTool { public static void ensureDirectoryExists(final Path file, final String errorTemplate) { Path parent = file.getParent(); try { if (parent != null) { Files.createDirectories(parent); } } catch (final IOException e) { throw buildError(parent, errorTemplate, e); } } private FileTool(); static void ensureDirectoryExists(final Path file, final String errorTemplate); static void writeMinimalJson(final Path file, final String errorTemplate); static void writeAsJson(final Path file, final Object v, final String errorTemplate); static T readFromJson(final Class<T> beanClass, final Path file, final String errorTemplate); }### Answer:
@Test public void testEnsureDirectoryExistsWithError() { Path impossible = existingFile.resolve("file"); assertThrows(SantaException.class, () -> FileTool.ensureDirectoryExists(impossible, ERROR_TEMPLATE)); }
@Test public void testEnsureDirectoryExistsWithDirectory() { FileTool.ensureDirectoryExists(existingFile, ERROR_TEMPLATE); assertTrue(Files.isDirectory(base)); }
@Test public void testEnsureDirectoryExistsWithError() { Path impossible = existingFile.resolve("file"); assertThrows(VocabHunterException.class, () -> FileTool.ensureDirectoryExists(impossible, ERROR_TEMPLATE)); }
@Test public void testEnsureDirectoryExistsWithoutBase() { Path file = Paths.get("file"); FileTool.ensureDirectoryExists(file, ERROR_TEMPLATE); } |
### Question:
FileTool { public static void writeMinimalJson(final Path file, final String errorTemplate) { try { Files.write(file, MINIMAL_JSON); } catch (final IOException e) { throw buildError(file, errorTemplate, e); } } private FileTool(); static void ensureDirectoryExists(final Path file, final String errorTemplate); static void writeMinimalJson(final Path file, final String errorTemplate); static void writeAsJson(final Path file, final Object v, final String errorTemplate); static T readFromJson(final Class<T> beanClass, final Path file, final String errorTemplate); }### Answer:
@Test public void testWriteMinimalJsonFailure() { assertThrows(SantaException.class, () -> FileTool.writeMinimalJson(subDirectory, ERROR_TEMPLATE)); }
@Test public void testWriteMinimalJsonSuccess() throws Exception { FileTool.writeMinimalJson(newFile, ERROR_TEMPLATE); List<String> result = Files.readAllLines(newFile); List<String> expected = List.of("{}"); assertEquals(expected, result); }
@Test public void testWriteMinimalJsonFailure() { assertThrows(VocabHunterException.class, () -> FileTool.writeMinimalJson(subDirectory, ERROR_TEMPLATE)); } |
### Question:
FileTool { public static void writeAsJson(final Path file, final Object v, final String errorTemplate) { try { MAPPER.writeValue(file.toFile(), v); } catch (final IOException e) { throw buildError(file, errorTemplate, e); } } private FileTool(); static void ensureDirectoryExists(final Path file, final String errorTemplate); static void writeMinimalJson(final Path file, final String errorTemplate); static void writeAsJson(final Path file, final Object v, final String errorTemplate); static T readFromJson(final Class<T> beanClass, final Path file, final String errorTemplate); }### Answer:
@Test public void testWriteAsJsonWithError() { assertThrows(SantaException.class, () -> FileTool.writeAsJson(subDirectory, new FileToolTestBean(), ERROR_TEMPLATE)); }
@Test public void testWriteAsJsonWithError() { assertThrows(VocabHunterException.class, () -> FileTool.writeAsJson(subDirectory, new FileToolTestBean(), ERROR_TEMPLATE)); } |
### Question:
FileTool { public static <T> T readFromJson(final Class<T> beanClass, final Path file, final String errorTemplate) { try { return MAPPER.readValue(file.toFile(), beanClass); } catch (final IOException e) { throw buildError(file, errorTemplate, e); } } private FileTool(); static void ensureDirectoryExists(final Path file, final String errorTemplate); static void writeMinimalJson(final Path file, final String errorTemplate); static void writeAsJson(final Path file, final Object v, final String errorTemplate); static T readFromJson(final Class<T> beanClass, final Path file, final String errorTemplate); }### Answer:
@Test public void testReadFromJsonWithError() { assertThrows(SantaException.class, () -> FileTool.readFromJson(FileToolTestBean.class, subDirectory, ERROR_TEMPLATE)); }
@Test public void testReadFromJsonWithError() { assertThrows(VocabHunterException.class, () -> FileTool.readFromJson(FileToolTestBean.class, subDirectory, ERROR_TEMPLATE)); } |
### Question:
Bits { public static long set(final long v, final int bit) { return v | 1 << bit; } static long set(final long v, final int bit); static int set(final int v, final int bit); static long unset(final long v, final int bit); static int unset(final int v, final int bit); }### Answer:
@Test public void testSet() { assertEquals(3, Bits.set(2, 0)); assertEquals(3, Bits.set(1, 1)); assertEquals(1, Bits.set(1, 0)); } |
### Question:
DefaultHttp2FrameReader implements Http2FrameReader, Http2FrameSizePolicy, Configuration { @SuppressWarnings("checkstyle:FinalParameters") private void readUnknownFrame( final ChannelHandlerContext ctx, ByteBuf payload, final int payloadEndIndex, final Http2FrameListener listener) throws Http2Exception { payload = payload.readSlice(payloadEndIndex - payload.readerIndex()); listener.onUnknownFrame(ctx, frameType, streamId, flags, payload); } DefaultHttp2FrameReader(); DefaultHttp2FrameReader(final boolean validateHeaders); DefaultHttp2FrameReader(final Http2HeadersDecoder headersDecoder); @Override Http2HeadersDecoder.Configuration headersConfiguration(); @Override Configuration configuration(); @Override Http2FrameSizePolicy frameSizePolicy(); @Override void maxFrameSize(final int max); @Override int maxFrameSize(); @Override void close(); @Override void readFrame(
final ChannelHandlerContext ctx, final ByteBuf input, final Http2FrameListener listener); }### Answer:
@Test public void readUnknownFrame() throws Http2Exception { final ByteBuf input = Unpooled.buffer(); final ByteBuf payload = Unpooled.buffer(); try { payload.writeByte(1); writeFrameHeader(input, payload.readableBytes(), (byte) 0xff, new Http2Flags(), 0); input.writeBytes(payload); frameReader.readFrame(ctx, input, listener); verify(listener).onUnknownFrame(ctx, (byte) 0xff, 0, new Http2Flags(), payload.slice(0, 1)); } finally { payload.release(); input.release(); } } |
### Question:
DefaultHttp2FrameReader implements Http2FrameReader, Http2FrameSizePolicy, Configuration { private void readPriorityFrame( final ChannelHandlerContext ctx, final ByteBuf payload, final Http2FrameListener listener) throws Http2Exception { final long word1 = payload.readUnsignedInt(); final boolean exclusive = (word1 & 0x80000000L) != 0; final int streamDependency = (int) (word1 & 0x7FFFFFFFL); if (streamDependency == streamId) { throw streamError(streamId, PROTOCOL_ERROR, "A stream cannot depend on itself."); } final short weight = (short) (payload.readUnsignedByte() + 1); listener.onPriorityRead(ctx, streamId, streamDependency, weight, exclusive); } DefaultHttp2FrameReader(); DefaultHttp2FrameReader(final boolean validateHeaders); DefaultHttp2FrameReader(final Http2HeadersDecoder headersDecoder); @Override Http2HeadersDecoder.Configuration headersConfiguration(); @Override Configuration configuration(); @Override Http2FrameSizePolicy frameSizePolicy(); @Override void maxFrameSize(final int max); @Override int maxFrameSize(); @Override void close(); @Override void readFrame(
final ChannelHandlerContext ctx, final ByteBuf input, final Http2FrameListener listener); }### Answer:
@Test public void readPriorityFrame() throws Http2Exception { final ByteBuf input = Unpooled.buffer(); try { writePriorityFrame(input, 1, 0, 10); frameReader.readFrame(ctx, input, listener); } finally { input.release(); } } |
### Question:
DefaultHttp2FrameReader implements Http2FrameReader, Http2FrameSizePolicy, Configuration { private void readSettingsFrame( final ChannelHandlerContext ctx, final ByteBuf payload, final Http2FrameListener listener) throws Http2Exception { if (flags.ack()) { listener.onSettingsAckRead(ctx); } else { final int numSettings = payloadLength / SETTING_ENTRY_LENGTH; final Http2Settings settings = new Http2Settings(); for (int index = 0; index < numSettings; ++index) { final char id = (char) payload.readUnsignedShort(); final long value = payload.readUnsignedInt(); try { settings.put(id, Long.valueOf(value)); } catch (final IllegalArgumentException e) { switch (id) { case SETTINGS_MAX_FRAME_SIZE: throw connectionError(PROTOCOL_ERROR, e, e.getMessage()); case SETTINGS_INITIAL_WINDOW_SIZE: throw connectionError(FLOW_CONTROL_ERROR, e, e.getMessage()); default: throw connectionError(PROTOCOL_ERROR, e, e.getMessage()); } } } listener.onSettingsRead(ctx, settings); } } DefaultHttp2FrameReader(); DefaultHttp2FrameReader(final boolean validateHeaders); DefaultHttp2FrameReader(final Http2HeadersDecoder headersDecoder); @Override Http2HeadersDecoder.Configuration headersConfiguration(); @Override Configuration configuration(); @Override Http2FrameSizePolicy frameSizePolicy(); @Override void maxFrameSize(final int max); @Override int maxFrameSize(); @Override void close(); @Override void readFrame(
final ChannelHandlerContext ctx, final ByteBuf input, final Http2FrameListener listener); }### Answer:
@Test public void readSettingsFrame() throws Http2Exception { final ByteBuf input = Unpooled.buffer(); try { writeFrameHeader(input, 6, SETTINGS, new Http2Flags(), 0); input.writeShort(SETTINGS_MAX_HEADER_LIST_SIZE); input.writeInt(1024); frameReader.readFrame(ctx, input, listener); listener.onSettingsRead(ctx, new Http2Settings().maxHeaderListSize(1024)); } finally { input.release(); } } |
### Question:
DefaultHttp2RemoteFlowController implements Http2RemoteFlowController { @Override public void initialWindowSize(final int newWindowSize) throws Http2Exception { assert ctx == null || ctx.executor().inEventLoop(); monitor.initialWindowSize(newWindowSize); } DefaultHttp2RemoteFlowController(final Http2Connection connection); DefaultHttp2RemoteFlowController(
final Http2Connection connection, final StreamByteDistributor streamByteDistributor); DefaultHttp2RemoteFlowController(
final Http2Connection connection, final Listener listener); DefaultHttp2RemoteFlowController(
final Http2Connection connection,
final StreamByteDistributor streamByteDistributor,
final Listener listener); @Override void channelHandlerContext(final ChannelHandlerContext ctx); @Override ChannelHandlerContext channelHandlerContext(); @Override void initialWindowSize(final int newWindowSize); @Override int initialWindowSize(); @Override int windowSize(final Http2Stream stream); @Override boolean isWritable(final Http2Stream stream); @Override void channelWritabilityChanged(); @Override void updateDependencyTree(
final int childStreamId,
final int parentStreamId,
final short weight,
final boolean exclusive); @Override void listener(final Listener listener); @Override void incrementWindowSize(final Http2Stream stream, final int delta); @Override void addFlowControlled(final Http2Stream stream, final FlowControlled frame); @Override boolean hasFlowControlled(final Http2Stream stream); @Override void writePendingBytes(); }### Answer:
@Test public void initialWindowSizeShouldOnlyChangeStreams() throws Http2Exception { controller.initialWindowSize(0); assertEquals(DEFAULT_WINDOW_SIZE, window(CONNECTION_STREAM_ID)); assertEquals(0, window(STREAM_A)); assertEquals(0, window(STREAM_B)); assertEquals(0, window(STREAM_C)); assertEquals(0, window(STREAM_D)); assertWritabilityChanged(1, false); } |
### Question:
DefaultHttp2RemoteFlowController implements Http2RemoteFlowController { @Override public void writePendingBytes() throws Http2Exception { monitor.writePendingBytes(); } DefaultHttp2RemoteFlowController(final Http2Connection connection); DefaultHttp2RemoteFlowController(
final Http2Connection connection, final StreamByteDistributor streamByteDistributor); DefaultHttp2RemoteFlowController(
final Http2Connection connection, final Listener listener); DefaultHttp2RemoteFlowController(
final Http2Connection connection,
final StreamByteDistributor streamByteDistributor,
final Listener listener); @Override void channelHandlerContext(final ChannelHandlerContext ctx); @Override ChannelHandlerContext channelHandlerContext(); @Override void initialWindowSize(final int newWindowSize); @Override int initialWindowSize(); @Override int windowSize(final Http2Stream stream); @Override boolean isWritable(final Http2Stream stream); @Override void channelWritabilityChanged(); @Override void updateDependencyTree(
final int childStreamId,
final int parentStreamId,
final short weight,
final boolean exclusive); @Override void listener(final Listener listener); @Override void incrementWindowSize(final Http2Stream stream, final int delta); @Override void addFlowControlled(final Http2Stream stream, final FlowControlled frame); @Override boolean hasFlowControlled(final Http2Stream stream); @Override void writePendingBytes(); }### Answer:
@Test public void payloadSmallerThanWindowShouldBeWrittenImmediately() throws Http2Exception { final FakeFlowControlled data = new FakeFlowControlled(5); sendData(STREAM_A, data); data.assertNotWritten(); verifyZeroInteractions(listener); controller.writePendingBytes(); data.assertFullyWritten(); verifyZeroInteractions(listener); }
@Test public void emptyPayloadShouldBeWrittenImmediately() throws Http2Exception { final FakeFlowControlled data = new FakeFlowControlled(0); sendData(STREAM_A, data); data.assertNotWritten(); controller.writePendingBytes(); data.assertFullyWritten(); verifyZeroInteractions(listener); } |
### Question:
ServerRetryHandler implements InboundHandler { @Override public void onReceivePacket(final Packet packet, final PipelineContext ctx) { requireNonNull(packet); requireNonNull(ctx); if (ctx.getState() == State.Started) { if (packet instanceof InitialPacket) { final InitialPacket initialPacket = (InitialPacket) packet; if (initialPacket.getToken().isPresent()) { if (retryTokenManager.validate( initialPacket.getToken().get(), ctx.getPeerAddress().getAddress(), now())) { } else { sendRetry(ctx, initialPacket); return; } } else { sendRetry(ctx, initialPacket); return; } } } ctx.next(packet); } ServerRetryHandler(
final RetryToken retryTokenManager, final long ttl, final TimeUnit timeUnit); @Override void onReceivePacket(final Packet packet, final PipelineContext ctx); }### Answer:
@Test public void retry() { final InitialPacket initialPacket = p(Optional.empty()); handler.onReceivePacket(initialPacket, ctx); assertToken(initialPacket.getSourceConnectionId()); verify(ctx, never()).next(any(Packet.class)); }
@Test public void withToken() { final InitialPacket initialPacket = p(of(retryToken.create(address, currentTimeMillis() + 10000))); handler.onReceivePacket(initialPacket, ctx); verify(ctx, never()).sendPacket(any(Packet.class)); verify(ctx).next(initialPacket); }
@Test public void withInvalidToken() { final InitialPacket initialPacket = p(of("this is not a token".getBytes())); handler.onReceivePacket(initialPacket, ctx); assertToken(initialPacket.getSourceConnectionId()); verify(ctx, never()).next(any(Packet.class)); }
@Test public void verifyState() { when(ctx.getState()).thenReturn(State.BeforeHello); final InitialPacket initialPacket = p(Optional.empty()); handler.onReceivePacket(initialPacket, ctx); verify(ctx, never()).sendPacket(any(RetryPacket.class)); verify(ctx).next(initialPacket); } |
### Question:
DefaultHttp2LocalFlowController implements Http2LocalFlowController { public void windowUpdateRatio(final float ratio) { assert ctx == null || ctx.executor().inEventLoop(); checkValidRatio(ratio); windowUpdateRatio = ratio; } DefaultHttp2LocalFlowController(final Http2Connection connection); DefaultHttp2LocalFlowController(
final Http2Connection connection,
final float windowUpdateRatio,
final boolean autoRefillConnectionWindow); @Override DefaultHttp2LocalFlowController frameWriter(final Http2FrameWriter frameWriter); @Override void channelHandlerContext(final ChannelHandlerContext ctx); @Override void initialWindowSize(final int newWindowSize); @Override int initialWindowSize(); @Override int windowSize(final Http2Stream stream); @Override int initialWindowSize(final Http2Stream stream); @Override void incrementWindowSize(final Http2Stream stream, final int delta); @Override boolean consumeBytes(final Http2Stream stream, final int numBytes); @Override int unconsumedBytes(final Http2Stream stream); void windowUpdateRatio(final float ratio); float windowUpdateRatio(); void windowUpdateRatio(final Http2Stream stream, final float ratio); float windowUpdateRatio(final Http2Stream stream); @Override void receiveFlowControlledFrame(
final Http2Stream stream, final ByteBuf data, final int padding, final boolean endOfStream); static final float DEFAULT_WINDOW_UPDATE_RATIO; }### Answer:
@Test public void globalRatioShouldImpactStreams() throws Http2Exception { final float ratio = 0.6f; controller.windowUpdateRatio(ratio); testRatio(ratio, DEFAULT_WINDOW_SIZE << 1, 3, false); } |
### Question:
DefaultHttp2HeadersEncoder implements Http2HeadersEncoder, Http2HeadersEncoder.Configuration { @Override public void encodeHeaders(final int streamId, final Http2Headers headers, final ByteBuf buffer) throws Http2Exception { try { if (tableSizeChangeOutput.isReadable()) { buffer.writeBytes(tableSizeChangeOutput); tableSizeChangeOutput.clear(); } hpackEncoder.encodeHeaders(streamId, buffer, headers, sensitivityDetector); } catch (final Http2Exception e) { throw e; } catch (final Throwable t) { throw connectionError( Http2Error.COMPRESSION_ERROR, t, "Failed encoding headers block: %s", t.getMessage()); } } DefaultHttp2HeadersEncoder(); DefaultHttp2HeadersEncoder(final SensitivityDetector sensitivityDetector); DefaultHttp2HeadersEncoder(
final SensitivityDetector sensitivityDetector, final boolean ignoreMaxHeaderListSize); DefaultHttp2HeadersEncoder(
final SensitivityDetector sensitivityDetector,
final boolean ignoreMaxHeaderListSize,
final int dynamicTableArraySizeHint); DefaultHttp2HeadersEncoder(
final SensitivityDetector sensitivityDetector, final HpackEncoder hpackEncoder); @Override void encodeHeaders(final int streamId, final Http2Headers headers, final ByteBuf buffer); @Override void maxHeaderTableSize(final long max); @Override long maxHeaderTableSize(); @Override void maxHeaderListSize(final long max); @Override long maxHeaderListSize(); @Override Configuration configuration(); }### Answer:
@Test public void encodeShouldSucceed() throws Http2Exception { final Http2Headers headers = headers(); final ByteBuf buf = Unpooled.buffer(); try { encoder.encodeHeaders(3 , headers, buf); assertTrue(buf.writerIndex() > 0); } finally { buf.release(); } } |
### Question:
ConnectionId { public static ConnectionId random() { final byte[] id = new byte[LENGTH]; Rnd.rndBytes(id); return new ConnectionId(id); } ConnectionId(final byte[] id); static ConnectionId random(); static ConnectionId read(final int length, final ByteBuf bb); static Optional<ConnectionId> readOptional(final int length, final ByteBuf bb); static Pair<Optional<ConnectionId>, Optional<ConnectionId>> readPair(final ByteBuf bb); static int lastLength(final int cil); static void write(
final Optional<ConnectionId> first, final Optional<ConnectionId> second, final ByteBuf bb); void write(final ByteBuf bb); int getLength(); byte[] asBytes(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final int LENGTH; }### Answer:
@Test public void roundtrip() { assertRoundtrip(ConnectionId.random()); } |
### Question:
Http2FrameCodec extends Http2ConnectionHandler { final boolean consumeBytes(final int streamId, final int bytes) throws Http2Exception { final Http2Stream stream = connection().stream(streamId); if (stream != null && streamId == Http2CodecUtil.HTTP_UPGRADE_STREAM_ID) { final Boolean upgraded = stream.getProperty(upgradeKey); if (Boolean.TRUE.equals(upgraded)) { return false; } } return connection().local().flowController().consumeBytes(stream, bytes); } Http2FrameCodec(
final Http2ConnectionEncoder encoder,
final Http2ConnectionDecoder decoder,
final Http2Settings initialSettings,
final boolean decoupleCloseAndGoAway); @Override final void handlerAdded(final ChannelHandlerContext ctx); @Override final void userEventTriggered(final ChannelHandlerContext ctx, final Object evt); @Override void write(
final ChannelHandlerContext ctx, final Object msg, final ChannelPromise promise); }### Answer:
@Test public void flowControlShouldBeResilientToMissingStreams() throws Http2Exception { final Http2Connection conn = new DefaultHttp2Connection(true); final Http2ConnectionEncoder enc = new DefaultHttp2ConnectionEncoder(conn, new DefaultHttp2FrameWriter()); final Http2ConnectionDecoder dec = new DefaultHttp2ConnectionDecoder(conn, enc, new DefaultHttp2FrameReader()); final Http2FrameCodec codec = new Http2FrameCodec(enc, dec, new Http2Settings(), false); final EmbeddedChannel em = new EmbeddedChannel(codec); assertFalse(codec.consumeBytes(1, 1)); assertTrue(em.finishAndReleaseAll()); } |
### Question:
ConnectionId { public static void write( final Optional<ConnectionId> first, final Optional<ConnectionId> second, final ByteBuf bb) { final int dcil = first.map(id -> id.getLength() - 3).orElse(0); final int scil = second.map(id -> id.getLength() - 3).orElse(0); final int cil = (dcil << 4 | scil) & 0xFF; bb.writeByte(cil); first.ifPresent(c -> c.write(bb)); second.ifPresent(c -> c.write(bb)); } ConnectionId(final byte[] id); static ConnectionId random(); static ConnectionId read(final int length, final ByteBuf bb); static Optional<ConnectionId> readOptional(final int length, final ByteBuf bb); static Pair<Optional<ConnectionId>, Optional<ConnectionId>> readPair(final ByteBuf bb); static int lastLength(final int cil); static void write(
final Optional<ConnectionId> first, final Optional<ConnectionId> second, final ByteBuf bb); void write(final ByteBuf bb); int getLength(); byte[] asBytes(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final int LENGTH; }### Answer:
@Test public void writeIds() { final byte[] b16 = new byte[16]; final ConnectionId id16 = new ConnectionId(b16); final byte[] b18 = new byte[18]; Arrays.fill(b18, (byte) 1); final ConnectionId id18 = new ConnectionId(b18); final ByteBuf bb = Unpooled.buffer(); ConnectionId.write(of(id16), of(id18), bb); assertEquals(0xdf, bb.readByte() & 0xFF); final byte[] a16 = new byte[16]; bb.readBytes(a16); assertArrayEquals(b16, a16); final byte[] a18 = new byte[18]; bb.readBytes(a18); assertArrayEquals(b18, a18); } |
### Question:
Bits { public static long unset(final long v, final int bit) { return v & ~(1 << bit); } static long set(final long v, final int bit); static int set(final int v, final int bit); static long unset(final long v, final int bit); static int unset(final int v, final int bit); }### Answer:
@Test public void testUnset() { assertEquals(2, Bits.unset(3, 0)); assertEquals(0, Bits.unset(1, 0)); assertEquals(1, Bits.unset(1, 1)); } |
### Question:
ConnectionId { public static Pair<Optional<ConnectionId>, Optional<ConnectionId>> readPair(final ByteBuf bb) { final int cil = bb.readByte() & 0xFF; final int dcil = firstLength(cil); final int scil = lastLength(cil); return Pair.of(readOptional(dcil, bb), readOptional(scil, bb)); } ConnectionId(final byte[] id); static ConnectionId random(); static ConnectionId read(final int length, final ByteBuf bb); static Optional<ConnectionId> readOptional(final int length, final ByteBuf bb); static Pair<Optional<ConnectionId>, Optional<ConnectionId>> readPair(final ByteBuf bb); static int lastLength(final int cil); static void write(
final Optional<ConnectionId> first, final Optional<ConnectionId> second, final ByteBuf bb); void write(final ByteBuf bb); int getLength(); byte[] asBytes(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final int LENGTH; }### Answer:
@Test public void readPair() { final ByteBuf bb = Unpooled.buffer(); bb.writeByte(0xdf); final byte[] b16 = new byte[16]; bb.writeBytes(b16); final byte[] b18 = new byte[18]; Arrays.fill(b18, (byte) 1); bb.writeBytes(b18); final Pair<Optional<ConnectionId>, Optional<ConnectionId>> cids = ConnectionId.readPair(bb); assertArrayEquals(b16, cids.getFirst().get().asBytes()); assertArrayEquals(b18, cids.getSecond().get().asBytes()); } |
### Question:
PingFrame extends Frame { @Override public void write(final ByteBuf bb) { bb.writeByte(getType().getType()); } private PingFrame(); static PingFrame parse(final ByteBuf bb); @Override int calculateLength(); @Override void write(final ByteBuf bb); @Override String toString(); static final PingFrame INSTANCE; }### Answer:
@Test public void write() { final ByteBuf bb = Unpooled.buffer(); final PingFrame frame = PingFrame.INSTANCE; frame.write(bb); TestUtil.assertBuffer("01", bb); } |
### Question:
StreamFrame extends Frame { public static StreamFrame parse(final ByteBuf bb) { final byte firstByte = bb.readByte(); final boolean off = (firstByte & 0x04) == 0x04; final boolean len = (firstByte & 0x02) == 0x02; final boolean fin = (firstByte & 0x01) == 0x01; final long streamId = StreamId.parse(bb); final long offset; if (off) { offset = Varint.readAsLong(bb); } else { offset = 0; } final int length; if (len) { length = Varint.readAsInt(bb); } else { length = bb.readableBytes(); } final byte[] data = new byte[length]; bb.readBytes(data); return new StreamFrame(streamId, offset, fin, data); } StreamFrame(final long streamId, final long offset, final boolean fin, final byte[] data); static StreamFrame parse(final ByteBuf bb); long getStreamId(); long getOffset(); boolean isFin(); byte[] getData(); @Override void write(final ByteBuf bb); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void parse() { final ByteBuf bb = Unpooled.copiedBuffer(Hex.dehex("10c67daf169411a94e48656c6c6f")); final StreamFrame frame = StreamFrame.parse(bb); assertFalse(frame.isFin()); assertEquals(0, frame.getOffset()); assertEquals(467722447824726350L, frame.getStreamId()); assertArrayEquals(DATA, frame.getData()); } |
### Question:
Http2Settings extends CharObjectHashMap<Long> { @Override public Long put(final char key, final Long value) { verifyStandardSetting(key, value); return super.put(key, value); } Http2Settings(); Http2Settings(final int initialCapacity, final float loadFactor); Http2Settings(final int initialCapacity); @Override Long put(final char key, final Long value); Long headerTableSize(); Http2Settings headerTableSize(final long value); Boolean pushEnabled(); Http2Settings pushEnabled(final boolean enabled); Long maxConcurrentStreams(); Http2Settings maxConcurrentStreams(final long value); Integer initialWindowSize(); Http2Settings initialWindowSize(final int value); Integer maxFrameSize(); Http2Settings maxFrameSize(final int value); Long maxHeaderListSize(); Http2Settings maxHeaderListSize(final long value); Http2Settings copyFrom(final Http2Settings settings); Integer getIntValue(final char key); static Http2Settings defaultSettings(); }### Answer:
@Test public void nonStandardSettingsShouldBeSet() { final char key = 0; settings.put(key, (Long) 123L); assertEquals(123L, (long) settings.get(key)); }
@Test public void settingsShouldSupportUnsignedShort() { final char key = (char) (Short.MAX_VALUE + 1); settings.put(key, (Long) 123L); assertEquals(123L, (long) settings.get(key)); }
@Test public void headerTableSizeUnsignedInt() { settings.put(Http2CodecUtil.SETTINGS_HEADER_TABLE_SIZE, (Long) MAX_UNSIGNED_INT); assertEquals(MAX_UNSIGNED_INT, (long) settings.get(Http2CodecUtil.SETTINGS_HEADER_TABLE_SIZE)); }
@Test(expected = IllegalArgumentException.class) public void headerTableSizeBoundCheck() { settings.put(Http2CodecUtil.SETTINGS_HEADER_TABLE_SIZE, (Long) Long.MAX_VALUE); }
@Test(expected = IllegalArgumentException.class) public void headerTableSizeBoundCheck2() { settings.put(Http2CodecUtil.SETTINGS_HEADER_TABLE_SIZE, Long.valueOf(-1L)); } |
### Question:
Http2Settings extends CharObjectHashMap<Long> { public Long maxHeaderListSize() { return get(SETTINGS_MAX_HEADER_LIST_SIZE); } Http2Settings(); Http2Settings(final int initialCapacity, final float loadFactor); Http2Settings(final int initialCapacity); @Override Long put(final char key, final Long value); Long headerTableSize(); Http2Settings headerTableSize(final long value); Boolean pushEnabled(); Http2Settings pushEnabled(final boolean enabled); Long maxConcurrentStreams(); Http2Settings maxConcurrentStreams(final long value); Integer initialWindowSize(); Http2Settings initialWindowSize(final int value); Integer maxFrameSize(); Http2Settings maxFrameSize(final int value); Long maxHeaderListSize(); Http2Settings maxHeaderListSize(final long value); Http2Settings copyFrom(final Http2Settings settings); Integer getIntValue(final char key); static Http2Settings defaultSettings(); }### Answer:
@Test public void headerListSizeUnsignedInt() { settings.maxHeaderListSize(MAX_UNSIGNED_INT); assertEquals(MAX_UNSIGNED_INT, (long) settings.maxHeaderListSize()); }
@Test(expected = IllegalArgumentException.class) public void headerListSizeBoundCheck() { settings.maxHeaderListSize(Long.MAX_VALUE); } |
### Question:
PaddingFrame extends Frame { @Override public void write(final ByteBuf bb) { final byte[] b = new byte[length]; bb.writeBytes(b); } PaddingFrame(final int length); static PaddingFrame parse(final ByteBuf bb); @Override int calculateLength(); @Override void write(final ByteBuf bb); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void writeOne() { final PaddingFrame frame = new PaddingFrame(1); final ByteBuf bb = Unpooled.buffer(); frame.write(bb); TestUtil.assertBuffer("00", bb); } |
### Question:
PaddingFrame extends Frame { public static PaddingFrame parse(final ByteBuf bb) { int length = 0; while (bb.isReadable()) { final int pos = bb.readerIndex(); final byte b = bb.readByte(); if (b == 0) { length += 1; } else { bb.readerIndex(pos); break; } } if (length == 0) { throw new IllegalArgumentException("Illegal frame type"); } return new PaddingFrame(length); } PaddingFrame(final int length); static PaddingFrame parse(final ByteBuf bb); @Override int calculateLength(); @Override void write(final ByteBuf bb); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void parseOne() { final PaddingFrame frame = PaddingFrame.parse(Unpooled.copiedBuffer(Hex.dehex("00"))); assertEquals(new PaddingFrame(1), frame); }
@Test public void parseMulti() { final PaddingFrame frame = PaddingFrame.parse(Unpooled.copiedBuffer(Hex.dehex("000000000000"))); assertEquals(new PaddingFrame(6), frame); }
@Test public void parseTrailing() { final ByteBuf bb = Unpooled.copiedBuffer(Hex.dehex("000000000000FF")); final PaddingFrame frame = PaddingFrame.parse(bb); assertEquals(new PaddingFrame(6), frame); assertEquals(1, bb.readableBytes()); }
@Test(expected = IllegalArgumentException.class) public void parseIllegal() { PaddingFrame.parse(Unpooled.copiedBuffer(Hex.dehex("FF"))); } |
### Question:
DefaultHttp2Headers extends DefaultHeaders<CharSequence, CharSequence, Http2Headers> implements Http2Headers { @Override public Http2Headers authority(final CharSequence value) { set(PseudoHeaderName.AUTHORITY.value(), value); return this; } DefaultHttp2Headers(); @SuppressWarnings("unchecked") DefaultHttp2Headers(final boolean validate); @SuppressWarnings("unchecked") DefaultHttp2Headers(final boolean validate, final int arraySizeHint); @Override Http2Headers clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override Http2Headers method(final CharSequence value); @Override Http2Headers scheme(final CharSequence value); @Override Http2Headers authority(final CharSequence value); @Override Http2Headers path(final CharSequence value); @Override Http2Headers status(final CharSequence value); @Override CharSequence method(); @Override CharSequence scheme(); @Override CharSequence authority(); @Override CharSequence path(); @Override CharSequence status(); @Override boolean contains(final CharSequence name, final CharSequence value); @Override boolean contains(
final CharSequence name, final CharSequence value, final boolean caseInsensitive); }### Answer:
@Test public void testSetHeadersOrdersPseudoHeadersCorrectly() { final Http2Headers headers = newHeaders(); final Http2Headers other = new DefaultHttp2Headers().add("name2", "value2").authority("foo"); headers.set(other); verifyPseudoHeadersFirst(headers); assertEquals(other.size(), headers.size()); assertEquals("foo", headers.authority()); assertEquals("value2", headers.get("name2")); }
@Test public void testSetAllOrdersPseudoHeadersCorrectly() { final Http2Headers headers = newHeaders(); final Http2Headers other = new DefaultHttp2Headers().add("name2", "value2").authority("foo"); final int headersSizeBefore = headers.size(); headers.setAll(other); verifyPseudoHeadersFirst(headers); verifyAllPseudoHeadersPresent(headers); assertEquals(headersSizeBefore + 1, headers.size()); assertEquals("foo", headers.authority()); assertEquals("value2", headers.get("name2")); } |
### Question:
Http2MultiplexCodec extends Http2FrameCodec { @Override final void onHttp2StreamWritabilityChanged( final ChannelHandlerContext ctx, final Http2FrameStream stream, final boolean writable) { (((Http2MultiplexCodecStream) stream).channel).writabilityChanged(writable); } Http2MultiplexCodec(
final Http2ConnectionEncoder encoder,
final Http2ConnectionDecoder decoder,
final Http2Settings initialSettings,
final ChannelHandler inboundStreamHandler,
final ChannelHandler upgradeStreamHandler,
final boolean decoupleCloseAndGoAway); @Override void onHttpClientUpgrade(); @Override final void handlerAdded0(final ChannelHandlerContext ctx); @Override final void handlerRemoved0(final ChannelHandlerContext ctx); @Override final void channelReadComplete(final ChannelHandlerContext ctx); @Override final void channelRead(final ChannelHandlerContext ctx, final Object msg); }### Answer:
@Test public void writabilityAndFlowControl() { final LastInboundHandler inboundHandler = new LastInboundHandler(); final Http2StreamChannel childChannel = newInboundStream(3, false, inboundHandler); assertEquals("", inboundHandler.writabilityStates()); assertTrue(childChannel.isWritable()); childChannel.writeAndFlush(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())); codec.onHttp2StreamWritabilityChanged(codec.ctx, childChannel.stream(), true); assertTrue(childChannel.isWritable()); assertEquals("", inboundHandler.writabilityStates()); codec.onHttp2StreamWritabilityChanged(codec.ctx, childChannel.stream(), true); assertTrue(childChannel.isWritable()); assertEquals("", inboundHandler.writabilityStates()); codec.onHttp2StreamWritabilityChanged(codec.ctx, childChannel.stream(), false); assertFalse(childChannel.isWritable()); assertEquals("false", inboundHandler.writabilityStates()); codec.onHttp2StreamWritabilityChanged(codec.ctx, childChannel.stream(), false); assertFalse(childChannel.isWritable()); assertEquals("false", inboundHandler.writabilityStates()); } |
### Question:
HpackEncoder { public void setMaxHeaderTableSize(final ByteBuf out, final long maxHeaderTableSize) throws Http2Exception { if (maxHeaderTableSize < MIN_HEADER_TABLE_SIZE || maxHeaderTableSize > MAX_HEADER_TABLE_SIZE) { throw connectionError( PROTOCOL_ERROR, "Header Table Size must be >= %d and <= %d but was %d", MIN_HEADER_TABLE_SIZE, MAX_HEADER_TABLE_SIZE, maxHeaderTableSize); } if (this.maxHeaderTableSize == maxHeaderTableSize) { return; } this.maxHeaderTableSize = maxHeaderTableSize; ensureCapacity(0); encodeInteger(out, 0x20, 5, maxHeaderTableSize); } HpackEncoder(); HpackEncoder(final boolean ignoreMaxHeaderListSize); HpackEncoder(final boolean ignoreMaxHeaderListSize, final int arraySizeHint); void encodeHeaders(
final int streamId,
final ByteBuf out,
final Http2Headers headers,
final SensitivityDetector sensitivityDetector); void setMaxHeaderTableSize(final ByteBuf out, final long maxHeaderTableSize); long getMaxHeaderTableSize(); void setMaxHeaderListSize(final long maxHeaderListSize); long getMaxHeaderListSize(); }### Answer:
@Test(expected = Http2Exception.class) public void testSetMaxHeaderTableSizeOverflow() throws Http2Exception { final ByteBuf buf = Unpooled.buffer(); try { hpackEncoder.setMaxHeaderTableSize(buf, MAX_HEADER_TABLE_SIZE + 1); } finally { buf.release(); } } |
### Question:
DefaultHttp2Connection implements Http2Connection { @Override public Http2Stream stream(final int streamId) { return streamMap.get(streamId); } DefaultHttp2Connection(final boolean server); DefaultHttp2Connection(final boolean server, final int maxReservedStreams); @Override Future<Void> close(final Promise<Void> promise); @Override void addListener(final Listener listener); @Override void removeListener(final Listener listener); @Override boolean isServer(); @Override Http2Stream connectionStream(); @Override Http2Stream stream(final int streamId); @Override boolean streamMayHaveExisted(final int streamId); @Override int numActiveStreams(); @Override Http2Stream forEachActiveStream(final Http2StreamVisitor visitor); @Override Endpoint<Http2LocalFlowController> local(); @Override Endpoint<Http2RemoteFlowController> remote(); @Override boolean goAwayReceived(); @Override void goAwayReceived(
final int lastKnownStream, final long errorCode, final ByteBuf debugData); @Override boolean goAwaySent(); @Override boolean goAwaySent(
final int lastKnownStream, final long errorCode, final ByteBuf debugData); @Override PropertyKey newKey(); }### Answer:
@Test public void getStreamWithoutStreamShouldReturnNull() { assertNull(server.stream(100)); } |
### Question:
PaddingFrame extends Frame { @Override public int calculateLength() { return length; } PaddingFrame(final int length); static PaddingFrame parse(final ByteBuf bb); @Override int calculateLength(); @Override void write(final ByteBuf bb); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void calculateLength() { assertEquals(10, new PaddingFrame(10).calculateLength()); } |
### Question:
AEADs { public AEAD get(final EncryptionLevel level) { requireNonNull(level); if (level == EncryptionLevel.Initial) { final AEAD aead = initialAead.get(); if (aead == null) { throw new IllegalStateException("Initial AEAD not set"); } log.debug("Using initial AEAD: {}", aead); return aead; } else if (level == EncryptionLevel.Handshake) { final AEAD aead = handshakeAead.get(); if (aead == null) { throw new IllegalStateException("Handshake AEAD not set"); } log.debug("Using handshake AEAD: {}", aead); return aead; } else { final AEAD aead = oneRttAead.get(); if (aead == null) { throw new IllegalStateException("1-RTT AEAD not set"); } log.debug("Using 1-RTT AEAD: {}", aead); return aead; } } AEADs(final AEAD initialAead); boolean available(final EncryptionLevel level); AEAD get(final EncryptionLevel level); void unsetInitialAead(); void unsetHandshakeAead(); void setHandshakeAead(final AEAD handshakeAead); void setOneRttAead(final AEAD oneRttAead); }### Answer:
@Test(expected = IllegalStateException.class) public void getHandshakeNotSet() { aeads.get(EncryptionLevel.Handshake); }
@Test(expected = IllegalStateException.class) public void getOneRttNotSet() { aeads.get(EncryptionLevel.OneRtt); }
@Test(expected = NullPointerException.class) public void getNullEncryptionLevel() { aeads.get(null); } |
### Question:
AEADs { public void setHandshakeAead(final AEAD handshakeAead) { this.handshakeAead.set(requireNonNull(handshakeAead)); } AEADs(final AEAD initialAead); boolean available(final EncryptionLevel level); AEAD get(final EncryptionLevel level); void unsetInitialAead(); void unsetHandshakeAead(); void setHandshakeAead(final AEAD handshakeAead); void setOneRttAead(final AEAD oneRttAead); }### Answer:
@Test(expected = NullPointerException.class) public void setNullHandshake() { aeads.setHandshakeAead(null); } |
### Question:
AEADs { public void setOneRttAead(final AEAD oneRttAead) { this.oneRttAead.set(requireNonNull(oneRttAead)); } AEADs(final AEAD initialAead); boolean available(final EncryptionLevel level); AEAD get(final EncryptionLevel level); void unsetInitialAead(); void unsetHandshakeAead(); void setHandshakeAead(final AEAD handshakeAead); void setOneRttAead(final AEAD oneRttAead); }### Answer:
@Test(expected = NullPointerException.class) public void setNullOneRtt() { aeads.setOneRttAead(null); } |
### Question:
AEAD { public byte[] seal(final byte[] src, final long packetNumber, final byte[] aad) throws GeneralSecurityException { return process(src, packetNumber, aad, myKey, myIV, Cipher.ENCRYPT_MODE); } AEAD(
final byte[] myKey,
final byte[] otherKey,
final byte[] myIV,
final byte[] otherIV,
final byte[] myPnKey,
final byte[] otherPnKey); byte[] open(final byte[] src, final long packetNumber, final byte[] aad); byte[] seal(final byte[] src, final long packetNumber, final byte[] aad); int getSampleLength(); byte[] decryptHeader(final byte[] sample, final byte[] bs, final boolean shortHeader); byte[] encryptHeader(final byte[] sample, final byte[] bs, final boolean shortHeader); byte[] getMyKey(); byte[] getOtherKey(); byte[] getMyIV(); byte[] getOtherIV(); byte[] getMyPnKey(); byte[] getOtherPnKey(); @Override String toString(); static final int OVERHEAD; }### Answer:
@Test public void seal() throws GeneralSecurityException { final byte[] actual = aead.seal(plainText, packetNumber, aad); assertArrayEquals(myCipherText, actual); }
@Test(expected = IllegalArgumentException.class) public void sealNullAad() throws GeneralSecurityException { aead.seal(plainText, packetNumber, null); }
@Test(expected = IllegalArgumentException.class) public void sealNullSrc() throws GeneralSecurityException { aead.seal(null, packetNumber, aad); } |
### Question:
AckFrame extends Frame { @Override public void write(final ByteBuf bb) { bb.writeByte(getType().getType()); final AckBlock firstBlock = blocks.get(0); Varint.write(firstBlock.getLargest(), bb); Varint.write(ackDelay, bb); Varint.write((blocks.size() - 1) * 2, bb); final long largest = firstBlock.getLargest(); long smallest = firstBlock.getSmallest(); Varint.write(largest - smallest, bb); for (int i = 1; i < blocks.size(); i++) { final AckBlock block = blocks.get(i); final long gap = smallest - block.getLargest() - 1; Varint.write(gap, bb); final long nextBlock = block.getLargest() - block.getSmallest(); smallest = block.getSmallest(); Varint.write(nextBlock, bb); } } AckFrame(final long ackDelay, final AckBlock... blocks); AckFrame(final long ackDelay, final List<AckBlock> blocks); static AckFrame parse(final ByteBuf bb); long getAckDelay(); List<AckBlock> getBlocks(); @Override void write(final ByteBuf bb); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void writeSinglePacket() { final List<AckBlock> blocks = List.of(new AckBlock(100, 100)); final AckFrame frame = new AckFrame(1234, blocks); final ByteBuf bb = Unpooled.buffer(); frame.write(bb); assertEquals("02406444d20000", Hex.hex(Bytes.drainToArray(bb))); } |
### Question:
Varint { public static void write(final long value, final ByteBuf bb) { checkRange(value); bb.writeBytes(write(value)); } static long random(); static long random(final int min); static long readAsLong(final ByteBuf bb); static long readAsLong(final byte[] b); static int readAsInt(final ByteBuf bb); static int readAsInt(final byte[] b); static byte readAsByte(final ByteBuf bb); static void write(final long value, final ByteBuf bb); static byte[] write(final long value); static final long MAX; }### Answer:
@Test public void validateBounds() { final ByteBuf bb = Unpooled.buffer(); Varint.write(0, bb); Varint.write(123, bb); Varint.write(4611686018427387903L, bb); }
@Test(expected = IllegalArgumentException.class) public void validateBoundsTooSmall() { final ByteBuf bb = Unpooled.buffer(); Varint.write(-1, bb); }
@Test(expected = IllegalArgumentException.class) public void validateBoundsTooLarge() { final ByteBuf bb = Unpooled.buffer(); Varint.write(4611686018427387904L, bb); } |
### Question:
AEAD { public byte[] open(final byte[] src, final long packetNumber, final byte[] aad) throws GeneralSecurityException { return process(src, packetNumber, aad, otherKey, otherIV, Cipher.DECRYPT_MODE); } AEAD(
final byte[] myKey,
final byte[] otherKey,
final byte[] myIV,
final byte[] otherIV,
final byte[] myPnKey,
final byte[] otherPnKey); byte[] open(final byte[] src, final long packetNumber, final byte[] aad); byte[] seal(final byte[] src, final long packetNumber, final byte[] aad); int getSampleLength(); byte[] decryptHeader(final byte[] sample, final byte[] bs, final boolean shortHeader); byte[] encryptHeader(final byte[] sample, final byte[] bs, final boolean shortHeader); byte[] getMyKey(); byte[] getOtherKey(); byte[] getMyIV(); byte[] getOtherIV(); byte[] getMyPnKey(); byte[] getOtherPnKey(); @Override String toString(); static final int OVERHEAD; }### Answer:
@Test public void open() throws GeneralSecurityException { final byte[] actual = aead.open(otherCipherText, packetNumber, aad); assertArrayEquals(plainText, actual); }
@Test(expected = AEADBadTagException.class) public void openBadAad() throws GeneralSecurityException { final byte[] actual = aead.open(otherCipherText, packetNumber, new byte[aad.length]); assertArrayEquals(plainText, actual); } |
### Question:
AEAD { public AEAD( final byte[] myKey, final byte[] otherKey, final byte[] myIV, final byte[] otherIV, final byte[] myPnKey, final byte[] otherPnKey) { this.myKey = prepareKey(myKey); this.otherKey = prepareKey(otherKey); this.myIV = prepareIV(myIV); this.otherIV = prepareIV(otherIV); this.myPnKey = prepareKey(myPnKey); this.otherPnKey = prepareKey(otherPnKey); } AEAD(
final byte[] myKey,
final byte[] otherKey,
final byte[] myIV,
final byte[] otherIV,
final byte[] myPnKey,
final byte[] otherPnKey); byte[] open(final byte[] src, final long packetNumber, final byte[] aad); byte[] seal(final byte[] src, final long packetNumber, final byte[] aad); int getSampleLength(); byte[] decryptHeader(final byte[] sample, final byte[] bs, final boolean shortHeader); byte[] encryptHeader(final byte[] sample, final byte[] bs, final boolean shortHeader); byte[] getMyKey(); byte[] getOtherKey(); byte[] getMyIV(); byte[] getOtherIV(); byte[] getMyPnKey(); byte[] getOtherPnKey(); @Override String toString(); static final int OVERHEAD; }### Answer:
@Test public void testAEAD() throws GeneralSecurityException { final AEAD testAEAD = TestAEAD.create(); final byte[] ct = testAEAD.seal(plainText, packetNumber, aad); final byte[] pt = testAEAD.open(ct, packetNumber, aad); assertArrayEquals(pt, plainText); } |
### Question:
StreamId { public static long validate(final long id) { Preconditions.checkArgument(id >= 0); Preconditions.checkArgument(id <= Varint.MAX); return id; } private StreamId(); static long random(final boolean client, final boolean bidirectional); static long next(final long prev, final boolean client, final boolean bidirectional); static long parse(final ByteBuf bb); static long validate(final long id); static boolean isClient(final long id); static boolean isBidirectional(final long id); static void write(final ByteBuf bb, final long id); }### Answer:
@Test public void validateBounds() { StreamId.validate(0); StreamId.validate(123); StreamId.validate(4611686018427387903L); }
@Test(expected = IllegalArgumentException.class) public void validateBoundsTooSmall() { StreamId.validate(-1); }
@Test(expected = IllegalArgumentException.class) public void validateBoundsTooLarge() { StreamId.validate(4611686018427387904L); } |
### Question:
ClientTlsSession { public byte[] startHandshake() { if (clientHello != null) { throw new IllegalStateException("Already started"); } final ClientHello ch = ClientHello.defaults(kek, transportParameters); clientHello = Bytes.write(bb -> ch.write(bb, true)); return clientHello; } ClientTlsSession(
final AEAD initialAEAD,
final TransportParameters transportParameters,
final CertificateValidator certificateValidator); byte[] startHandshake(); AEAD handleServerHello(final byte[] msg); synchronized Optional<HandshakeResult> handleHandshake(final byte[] msg); boolean available(final EncryptionLevel encLevel); AEAD getAEAD(final EncryptionLevel level); void setHandshakeAead(final AEAD handshakeAead); void setOneRttAead(final AEAD oneRttAead); void unsetInitialAead(); void unsetHandshakeAead(); }### Answer:
@Test public void handshake() { final byte[] ch = engine.startHandshake(); final ClientHello hello = ClientHello.parse(ch, false); assertEquals(32, hello.getClientRandom().length); assertEquals(0, hello.getSessionId().length); assertEquals(List.of(TLS_AES_128_GCM_SHA256), hello.getCipherSuites()); assertEquals( 32, ((KeyShare) hello.getExtension(ExtensionType.KEY_SHARE).get()) .getKey(Group.X25519) .get() .length); assertEquals( List.of(Group.X25519), ((SupportedGroups) hello.getExtension(ExtensionType.SUPPORTED_GROUPS).get()).getGroups()); assertEquals( List.of(SupportedVersion.TLS13), ((SupportedVersions) hello.getExtension(ExtensionType.SUPPORTED_VERSIONS).get()) .getVersions()); final TransportParameters tps = (TransportParameters) hello.getExtension(ExtensionType.QUIC).get(); assertEquals(TestUtil.tps(), tps); } |
### Question:
VerifyData { public static byte[] create(final byte[] handshakeTrafficSecret, final byte[] finishedHash) { checkArgument(handshakeTrafficSecret.length == 32); checkArgument(finishedHash.length == 32); final byte[] finishedKey = HKDF.expandLabel(handshakeTrafficSecret, FINISHED, new byte[0], 32); return Hashing.hmacSha256(finishedKey).hashBytes(finishedHash).asBytes(); } static byte[] create(final byte[] handshakeTrafficSecret, final byte[] finishedHash); static boolean verify(
final byte[] verifyData,
final byte[] handshakeTrafficSecret,
final byte[] finishedHash,
final boolean quic); }### Answer:
@Test public void testCreate() { assertHex(tlsVD, create(handshakeTrafficSecret, finishedHash)); } |
### Question:
VerifyData { public static boolean verify( final byte[] verifyData, final byte[] handshakeTrafficSecret, final byte[] finishedHash, final boolean quic) { checkArgument(verifyData.length > 0); checkArgument(handshakeTrafficSecret.length == 32); checkArgument(finishedHash.length == 32); final byte[] actual = create(handshakeTrafficSecret, finishedHash); return CryptoEquals.isEqual(verifyData, actual); } static byte[] create(final byte[] handshakeTrafficSecret, final byte[] finishedHash); static boolean verify(
final byte[] verifyData,
final byte[] handshakeTrafficSecret,
final byte[] finishedHash,
final boolean quic); }### Answer:
@Test public void testVerify() { assertTrue(VerifyData.verify(tlsVD, handshakeTrafficSecret, finishedHash, false)); assertFalse(VerifyData.verify(Rnd.rndBytes(32), handshakeTrafficSecret, finishedHash, false)); } |
### Question:
Hash { public static byte[] sha256(final byte[]... data) { return digests.get().digest(Bytes.concat(data)); } static byte[] sha256(final byte[]... data); }### Answer:
@Test public void multiple256() { TestUtil.assertHex( "936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af", Hash.sha256("hello".getBytes(), "world".getBytes())); }
@Test public void single256() { TestUtil.assertHex( "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", Hash.sha256("hello".getBytes())); }
@Test public void empty256() { TestUtil.assertHex( "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", Hash.sha256()); }
@Test(expected = NullPointerException.class) public void null256() { Hash.sha256(null); } |
### Question:
KeyShare implements Extension { @Override public ExtensionType getType() { return ExtensionType.KEY_SHARE; } private KeyShare(final SortedMap<Group, byte[]> keys); static KeyShare parse(final ByteBuf bb, final boolean isClient); static KeyShare of(final Group group, final byte[] publicKey); static KeyShare of(
final Group group1, final byte[] key1, final Group group2, final byte[] key2); @Override ExtensionType getType(); SortedMap<Group, byte[]> getKeys(); Optional<byte[]> getKey(final Group group); @Override void write(final ByteBuf bb, final boolean isClient); @Override String toString(); }### Answer:
@Test public void getType() { assertEquals(ExtensionType.KEY_SHARE, ext.getType()); } |
### Question:
StreamId { public static long random(final boolean client, final boolean bidirectional) { return encodeType(client, bidirectional, Varint.random(4)); } private StreamId(); static long random(final boolean client, final boolean bidirectional); static long next(final long prev, final boolean client, final boolean bidirectional); static long parse(final ByteBuf bb); static long validate(final long id); static boolean isClient(final long id); static boolean isBidirectional(final long id); static void write(final ByteBuf bb, final long id); }### Answer:
@Test public void randomBounds() { for (int i = 0; i < 1000_000; i++) { final long v = StreamId.random(true, true); assertTrue(Long.toString(v), v > 1 && v < 4611686018427387903L); } } |
### Question:
StreamId { public static long next(final long prev, final boolean client, final boolean bidirectional) { long v = encodeType(client, bidirectional, prev); long tmp = v; while (v <= prev) { tmp++; v = encodeType(client, bidirectional, tmp); } return v; } private StreamId(); static long random(final boolean client, final boolean bidirectional); static long next(final long prev, final boolean client, final boolean bidirectional); static long parse(final ByteBuf bb); static long validate(final long id); static boolean isClient(final long id); static boolean isBidirectional(final long id); static void write(final ByteBuf bb, final long id); }### Answer:
@Test public void next() { assertEquals(3, StreamId.next(0, false, false)); assertEquals(1, StreamId.next(0, false, true)); assertEquals(4, StreamId.next(0, true, true)); } |
### Question:
Payload { public void write(final ByteBuf bb, final AEAD aead, final long pn, final byte[] aad) { final ByteBuf raw = Unpooled.buffer(); for (final Frame frame : frames) { frame.write(raw); } final byte[] b = Bytes.drainToArray(raw); try { final byte[] sealed = aead.seal(b, pn, aad); bb.writeBytes(sealed); } catch (final GeneralSecurityException e) { throw new RuntimeException(e); } } Payload(final List<Frame> frames); Payload(final Frame... frames); static Payload parse(
final ByteBuf bb, final int length, final AEAD aead, final long pn, final byte[] aad); List<Frame> getFrames(); Payload addFrame(final Frame frame); int calculateLength(); void write(final ByteBuf bb, final AEAD aead, final long pn, final byte[] aad); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void write() { final Payload payload = new Payload(PingFrame.INSTANCE, new PaddingFrame(1)); final ByteBuf bb = Unpooled.buffer(); payload.write(bb, aead, pn, aad); TestUtil.assertBuffer("e1eca61dcd946af283d48c55a5d25967efd6", bb); } |
### Question:
Payload { public static Payload parse( final ByteBuf bb, final int length, final AEAD aead, final long pn, final byte[] aad) { final byte[] cipherText = new byte[length]; bb.readBytes(cipherText); final byte[] raw; try { raw = aead.open(cipherText, pn, aad); } catch (final GeneralSecurityException e) { throw new RuntimeException(e); } final List<Frame> frames = new ArrayList<>(); final ByteBuf frameBuf = Unpooled.wrappedBuffer(raw); while (frameBuf.isReadable()) { final Frame frame = Frame.parse(frameBuf); frames.add(frame); } return new Payload(frames); } Payload(final List<Frame> frames); Payload(final Frame... frames); static Payload parse(
final ByteBuf bb, final int length, final AEAD aead, final long pn, final byte[] aad); List<Frame> getFrames(); Payload addFrame(final Frame frame); int calculateLength(); void write(final ByteBuf bb, final AEAD aead, final long pn, final byte[] aad); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void parse() { final ByteBuf bb = Unpooled.copiedBuffer(Hex.dehex("e1eca61dcd946af283d48c55a5d25967efd6")); final Payload parsed = Payload.parse(bb, bb.writerIndex(), aead, pn, aad); final Payload expected = new Payload(PingFrame.INSTANCE, new PaddingFrame(1)); assertEquals(expected, parsed); } |
### Question:
Payload { public Payload addFrame(final Frame frame) { final List<Frame> newFrames = new ArrayList<>(frames); newFrames.add(frame); return new Payload(newFrames); } Payload(final List<Frame> frames); Payload(final Frame... frames); static Payload parse(
final ByteBuf bb, final int length, final AEAD aead, final long pn, final byte[] aad); List<Frame> getFrames(); Payload addFrame(final Frame frame); int calculateLength(); void write(final ByteBuf bb, final AEAD aead, final long pn, final byte[] aad); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void addFrame() { final Payload payload = new Payload(PingFrame.INSTANCE); final Payload withAdded = payload.addFrame(new PaddingFrame(1)); final Payload expected = new Payload(PingFrame.INSTANCE, new PaddingFrame(1)); assertEquals(expected, withAdded); assertEquals(new Payload(PingFrame.INSTANCE), payload); } |
### Question:
VersionNegotiationPacket implements Packet { @Override public void write(final ByteBuf bb, final AEAD notUsed) { int marker = Rnd.rndInt() & 0xFF; marker |= MARKER; bb.writeByte(marker); Version.VERSION_NEGOTIATION.write(bb); ConnectionId.write(destinationConnectionId, sourceConnectionId, bb); for (final Version version : supportedVersions) { version.write(bb); } } VersionNegotiationPacket(
final Optional<ConnectionId> destinationConnectionId,
final Optional<ConnectionId> sourceConnectionId,
final Version... supportedVersions); VersionNegotiationPacket(
final Optional<ConnectionId> destinationConnectionId,
final Optional<ConnectionId> sourceConnectionId,
final List<Version> supportedVersions); static HalfParsedPacket<VersionNegotiationPacket> parse(final ByteBuf bb); @Override void write(final ByteBuf bb, final AEAD notUsed); @Override Optional<ConnectionId> getSourceConnectionId(); @Override Optional<ConnectionId> getDestinationConnectionId(); List<Version> getSupportedVersions(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void randomMarker() { final ByteBuf bb = Unpooled.buffer(); packet.write(bb, aead); final byte marker1 = bb.readByte(); final ByteBuf bb2 = Unpooled.buffer(); packet.write(bb2, aead); final byte marker2 = bb2.readByte(); assertTrue((0x80 & marker1) == 0x80); assertTrue((0x80 & marker2) == 0x80); } |
### Question:
PacketNumber { public static long validate(final long number) { Preconditions.checkArgument(number >= 0); Preconditions.checkArgument(number <= Varint.MAX); return number; } private PacketNumber(); static long parse(final byte[] b); static long validate(final long number); static long next(final long number); static int getLength(final long number); static byte[] write(final long number, final int length); static final long MIN; }### Answer:
@Test public void validateBounds() { PacketNumber.validate(0); PacketNumber.validate(123); PacketNumber.validate(4611686018427387903L); }
@Test(expected = IllegalArgumentException.class) public void validateBoundsTooSmall() { PacketNumber.validate(-1); }
@Test(expected = IllegalArgumentException.class) public void validateBoundsTooLarge() { PacketNumber.validate(4611686018427387904L); } |
### Question:
PacketNumber { public static byte[] write(final long number, final int length) { final byte[] b = new byte[length]; for (int j = length; j > 0; j--) { b[length - j] = (byte) ((number >> (8 * (j - 1))) & 0xFF); } return b; } private PacketNumber(); static long parse(final byte[] b); static long validate(final long number); static long next(final long number); static int getLength(final long number); static byte[] write(final long number, final int length); static final long MIN; }### Answer:
@Test public void write() { final byte[] b = PacketNumber.write(123, 4); TestUtil.assertHex("0000007b", b); } |
### Question:
PacketNumber { public static long next(final long number) { return number + 1; } private PacketNumber(); static long parse(final byte[] b); static long validate(final long number); static long next(final long number); static int getLength(final long number); static byte[] write(final long number, final int length); static final long MIN; }### Answer:
@Test public void next() { final long pn = 123; assertEquals(124, PacketNumber.next(pn)); } |
### Question:
TerminationManager implements InboundHandler { @Override public void onReceivePacket(final Packet packet, final PipelineContext ctx) { if (packet instanceof FullPacket) { final FullPacket fp = (FullPacket) packet; for (final Frame frame : fp.getPayload().getFrames()) { if (frame instanceof ConnectionCloseFrame) { ctx.setState(State.Closing); connection.closeByPeer(); ctx.setState(State.Closed); } } } resetIdleTimer(); ctx.next(packet); } TerminationManager(
final InternalConnection connection,
final Timer timer,
final long idleTimeout,
final TimeUnit idleUnit); @Override void onReceivePacket(final Packet packet, final PipelineContext ctx); }### Answer:
@Test public void testConnectionCloseFrame() { final Packet packet = packet(new ConnectionCloseFrame(456, FrameType.PADDING, "Test")); manager.onReceivePacket(packet, ctx); verify(connection).closeByPeer(); verify(ctx).setState(State.Closing); verify(ctx).setState(State.Closed); verify(ctx).next(packet); }
@Test public void idleTimeout() throws Exception { assertTrue(timer.timeouts.isEmpty()); manager.onReceivePacket(packet(PingFrame.INSTANCE), ctx); assertFalse(timer.timeouts.isEmpty()); timer.trigger(); verify(connection).close(eq(TransportError.NO_ERROR), eq(FrameType.PADDING), anyString()); } |
### Question:
LoggingHandler implements InboundHandler, OutboundHandler { @Override public void onReceivePacket(final Packet packet, final PipelineContext ctx) { log.info("<<< {} received state={} packet={}", actor(), ctx.getState(), packet); ctx.next(packet); } LoggingHandler(final boolean isClient); @Override void onReceivePacket(final Packet packet, final PipelineContext ctx); @Override void beforeSendPacket(final Packet packet, final PipelineContext ctx); }### Answer:
@Test public void receive() { final Packet packet = p(PingFrame.INSTANCE); handler.onReceivePacket(packet, ctx); verify(ctx).next(packet); } |
### Question:
LoggingHandler implements InboundHandler, OutboundHandler { @Override public void beforeSendPacket(final Packet packet, final PipelineContext ctx) { log.info(">>> {} sent state={} packet={}", actor(), ctx.getState(), packet); ctx.next(packet); } LoggingHandler(final boolean isClient); @Override void onReceivePacket(final Packet packet, final PipelineContext ctx); @Override void beforeSendPacket(final Packet packet, final PipelineContext ctx); }### Answer:
@Test public void send() { final Packet packet = p(PingFrame.INSTANCE); handler.beforeSendPacket(packet, ctx); verify(ctx).next(packet); } |
### Question:
DefaultStreamManager implements StreamManager { @Override public Stream openStream(final boolean client, final boolean bidirectional) { return streams.openStream(client, bidirectional, listener); } DefaultStreamManager(final FrameSender frameSender, final StreamListener listener); @Override void onReceivePacket(final Packet packet, final PipelineContext ctx); @Override Stream openStream(final boolean client, final boolean bidirectional); }### Answer:
@Test public void streamSingleWrite() { final Stream stream = manager.openStream(true, true); stream.write(DATA1, true); verify(ctx).send(new StreamFrame(stream.getId(), 0, true, DATA1)); assertTrue(stream.isFinished()); }
@Test public void streamMultiWrite() { final Stream stream = manager.openStream(true, true); stream.write(DATA1, false); verify(ctx).send(new StreamFrame(stream.getId(), 0, false, DATA1)); assertFalse(stream.isFinished()); stream.write(DATA2, true); verify(ctx).send(new StreamFrame(stream.getId(), DATA1.length, true, DATA2)); assertTrue(stream.isFinished()); }
@Test public void streamReset() { final Stream stream = manager.openStream(true, true); stream.write(DATA1, false); verify(ctx).send(new StreamFrame(stream.getId(), 0, false, DATA1)); stream.reset(123); verify(ctx).send(new ResetStreamFrame(stream.getId(), 123, DATA1.length)); assertTrue(stream.isFinished()); } |
### Question:
DefaultStreamManager implements StreamManager { @Override public void onReceivePacket(final Packet packet, final PipelineContext ctx) { requireNonNull(packet); requireNonNull(ctx); if (packet instanceof ShortPacket) { final ShortPacket sp = (ShortPacket) packet; for (final Frame frame : sp.getPayload().getFrames()) { if (frame instanceof StreamFrame) { if (ctx.getState() != State.Ready) { throw new IllegalStateException("Stream frames can only be handled in ready state"); } final StreamFrame sf = (StreamFrame) frame; final DefaultStream stream = streams.getOrCreate(sf.getStreamId(), listener); stream.onData(sf.getOffset(), sf.isFin(), sf.getData()); } else if (frame instanceof ResetStreamFrame) { final ResetStreamFrame rsf = (ResetStreamFrame) frame; final DefaultStream stream = streams.getOrCreate(rsf.getStreamId(), listener); stream.onReset(rsf.getApplicationErrorCode(), rsf.getOffset()); } else if (frame instanceof AckFrame) { final AckFrame af = (AckFrame) frame; af.getBlocks().stream().forEach(this::handleAcks); } } } ctx.next(packet); } DefaultStreamManager(final FrameSender frameSender, final StreamListener listener); @Override void onReceivePacket(final Packet packet, final PipelineContext ctx); @Override Stream openStream(final boolean client, final boolean bidirectional); }### Answer:
@Test(expected = IllegalStateException.class) public void receiveInInvalidState() { when(ctx.getState()).thenReturn(State.BeforeReady); manager.onReceivePacket(p(new StreamFrame(0, 0, false, DATA1)), ctx); } |
### Question:
Streams { public Stream openStream( final boolean client, final boolean bidirectional, final StreamListener handler) { final StreamType type = bidirectional ? StreamType.Bidirectional : StreamType.Sending; final long streamId = StreamId.next(maxId, client, bidirectional); this.maxId = streamId; final DefaultStream stream = new DefaultStream(streamId, frameSender, handler, type); streams.put(streamId, stream); return stream; } Streams(final FrameSender frameSender); Stream openStream(
final boolean client, final boolean bidirectional, final StreamListener handler); DefaultStream getOrCreate(final long streamId, final StreamListener handler); void onAck(final long pn); }### Answer:
@Test public void openStream() { final Stream stream = streams.openStream(false, false, listener); assertEquals(3, stream.getId()); } |
### Question:
Streams { public DefaultStream getOrCreate(final long streamId, final StreamListener handler) { DefaultStream stream = streams.get(streamId); if (stream == null) { stream = new DefaultStream( streamId, frameSender, handler, StreamType.Bidirectional); final DefaultStream existingStream = streams.putIfAbsent(streamId, stream); if (existingStream != null) { stream = existingStream; } } return stream; } Streams(final FrameSender frameSender); Stream openStream(
final boolean client, final boolean bidirectional, final StreamListener handler); DefaultStream getOrCreate(final long streamId, final StreamListener handler); void onAck(final long pn); }### Answer:
@Test public void createAndThenGet() { final long streamId = StreamId.random(true, true); final DefaultStream stream1 = streams.getOrCreate(streamId, listener); final DefaultStream stream2 = streams.getOrCreate(streamId, listener); assertSame(stream1, stream2); final DefaultStream stream3 = streams.getOrCreate(StreamId.random(true, true), listener); assertNotSame(stream1, stream3); } |
### Question:
Varint { public static long random() { return random(0); } static long random(); static long random(final int min); static long readAsLong(final ByteBuf bb); static long readAsLong(final byte[] b); static int readAsInt(final ByteBuf bb); static int readAsInt(final byte[] b); static byte readAsByte(final ByteBuf bb); static void write(final long value, final ByteBuf bb); static byte[] write(final long value); static final long MAX; }### Answer:
@Test public void randomBounds() { for (int i = 0; i < 1000_000; i++) { final long v = Varint.random(); assertTrue(v > 0 && v < 4611686018427387903L); } } |
### Question:
AckDelay { public long calculate(final long delay, final TimeUnit unit) { return Math.max(unit.toMicros(delay) / ackDelayMultiplier, 0); } AckDelay(final int ackDelayExponent, final Ticker ticker); long calculate(final long delay, final TimeUnit unit); long time(); long delay(final long delay); }### Answer:
@Test public void toAckDelay() { assertEquals(100, ackDelay.calculate(800 * 1000, TimeUnit.NANOSECONDS)); }
@Test public void toAckDelayNegative() { assertEquals(0, ackDelay.calculate(-800 * 1000, TimeUnit.NANOSECONDS)); } |
### Question:
AckDelay { public long time() { return ticker.nanoTime(); } AckDelay(final int ackDelayExponent, final Ticker ticker); long calculate(final long delay, final TimeUnit unit); long time(); long delay(final long delay); }### Answer:
@Test public void time() { assertEquals(123, ackDelay.time()); } |
### Question:
AckDelay { public long delay(final long delay) { return Math.max(ticker.nanoTime() - delay, 0); } AckDelay(final int ackDelayExponent, final Ticker ticker); long calculate(final long delay, final TimeUnit unit); long time(); long delay(final long delay); }### Answer:
@Test public void delay() { assertEquals(23, ackDelay.delay(100)); }
@Test public void delayNegative() { assertEquals(0, ackDelay.delay(200)); } |
### Question:
PacketBuffer { public boolean remove(final long packetNumber) { return buffer.remove(packetNumber) != null; } PacketBuffer(final Ticker ticker); void put(final FullPacket packet); void clear(); boolean remove(final long packetNumber); boolean contains(final long packetNumber); boolean isEmpty(); Collection<Frame> drainSince(final long ttl, final TimeUnit unit); @Override String toString(); }### Answer:
@Test public void remove() { assertFalse(buffer.remove(pn1)); buffer.put(packet1); assertTrue(buffer.remove(pn1)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.