target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test void throwsExceptionWhenUpgradeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> CategoryScoreDetails.from(without( () -> sc2ApiCategoryScoreDetails().toBuilder(), ScoreOuterClass.CategoryScoreDetails.Builder::clearUpgrade).build())) .withMessage("upgrade is required");... | public static CategoryScoreDetails from(ScoreOuterClass.CategoryScoreDetails sc2ApiCategoryScoreDetails) { require("sc2api category score details", sc2ApiCategoryScoreDetails); return new CategoryScoreDetails(sc2ApiCategoryScoreDetails); } | CategoryScoreDetails implements Serializable { public static CategoryScoreDetails from(ScoreOuterClass.CategoryScoreDetails sc2ApiCategoryScoreDetails) { require("sc2api category score details", sc2ApiCategoryScoreDetails); return new CategoryScoreDetails(sc2ApiCategoryScoreDetails); } } | CategoryScoreDetails implements Serializable { public static CategoryScoreDetails from(ScoreOuterClass.CategoryScoreDetails sc2ApiCategoryScoreDetails) { require("sc2api category score details", sc2ApiCategoryScoreDetails); return new CategoryScoreDetails(sc2ApiCategoryScoreDetails); } private CategoryScoreDetails(Sco... | CategoryScoreDetails implements Serializable { public static CategoryScoreDetails from(ScoreOuterClass.CategoryScoreDetails sc2ApiCategoryScoreDetails) { require("sc2api category score details", sc2ApiCategoryScoreDetails); return new CategoryScoreDetails(sc2ApiCategoryScoreDetails); } private CategoryScoreDetails(Sco... | CategoryScoreDetails implements Serializable { public static CategoryScoreDetails from(ScoreOuterClass.CategoryScoreDetails sc2ApiCategoryScoreDetails) { require("sc2api category score details", sc2ApiCategoryScoreDetails); return new CategoryScoreDetails(sc2ApiCategoryScoreDetails); } private CategoryScoreDetails(Sco... |
@Test void throwsExceptionWhenSc2ApiScoreDetailsIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(nothing())) .withMessage("sc2api score details is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void convertsAllFieldsFromSc2ApiScoreDetails() { assertThatAllFieldsAreConverted(ScoreDetails.from(sc2ApiScoreDetails())); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenIdleProductionTimeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearIdleProductionTime).build())) .withMessage("idle production time is ... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenIdleWorkerTimeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearIdleWorkerTime).build())) .withMessage("idle worker time is required"); ... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenTotalValueUnitsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearTotalValueUnits).build())) .withMessage("total value units is required"... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenTotalValueStructuresIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearTotalValueStructures).build())) .withMessage("total value structur... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenThereIsNoActionCase() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> command().of((DebugDraw) nothing())) .withMessage("draw is required"); assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> command().of((DebugGameState) nothing())) .... | public static Builder command() { return new Builder(); } | DebugCommand implements Sc2ApiSerializable<Debug.DebugCommand> { public static Builder command() { return new Builder(); } } | DebugCommand implements Sc2ApiSerializable<Debug.DebugCommand> { public static Builder command() { return new Builder(); } private DebugCommand(DebugDraw draw); private DebugCommand(DebugGameState gameState); private DebugCommand(DebugCreateUnit createUnit); private DebugCommand(DebugKillUnit killUnit); private De... | DebugCommand implements Sc2ApiSerializable<Debug.DebugCommand> { public static Builder command() { return new Builder(); } private DebugCommand(DebugDraw draw); private DebugCommand(DebugGameState gameState); private DebugCommand(DebugCreateUnit createUnit); private DebugCommand(DebugKillUnit killUnit); private De... | DebugCommand implements Sc2ApiSerializable<Debug.DebugCommand> { public static Builder command() { return new Builder(); } private DebugCommand(DebugDraw draw); private DebugCommand(DebugGameState gameState); private DebugCommand(DebugCreateUnit createUnit); private DebugCommand(DebugKillUnit killUnit); private De... |
@Test void throwsExceptionWhenKilledValueUnitsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearKilledValueUnits).build())) .withMessage("killed value units is requir... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenKilledValueStructuresIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearKilledValueStructures).build())) .withMessage("killed value struc... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenCollectedMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearCollectedMinerals).build())) .withMessage("collected minerals is requ... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenCollectedVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearCollectedVespene).build())) .withMessage("collected vespene is require... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenCollectionRateMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearCollectionRateMinerals).build())) .withMessage("collection rate ... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenCollectionRateVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearCollectionRateVespene).build())) .withMessage("collection rate ve... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenSpentMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearSpentMinerals).build())) .withMessage("spent minerals is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenSpentVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearSpentVespene).build())) .withMessage("spent vespene is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenFoodUsedIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearFoodUsed).build())) .withMessage("food used is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenKilledMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearKilledMinerals).build())) .withMessage("killed minerals is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenUnitValueIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(setUnitValue().forUnit(Tag.from(UNIT_TAG))) .to(VITAL_SCORE_ENERGY).build()) .withMessage("unit value is required"); } | public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); static DebugSetUnitValueSyntax setUnitValue(); @Override Debug.DebugSetUnitValue toSc... | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); static DebugSetUnitValueSyntax setUnitValue(); @Override Debug.DebugSetUnitValue toSc... |
@Test void throwsExceptionWhenKilledVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearKilledVespene).build())) .withMessage("killed vespene is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenLostMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearLostMinerals).build())) .withMessage("lost minerals is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenLostVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearLostVespene).build())) .withMessage("lost vespene is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenFriendlyFireMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearFriendlyFireMinerals).build())) .withMessage("friendly fire minera... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenFriendlyFireVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearFriendlyFireVespene).build())) .withMessage("friendly fire vespene ... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenUsedMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearUsedMinerals).build())) .withMessage("used minerals is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenUsedVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearUsedVespene).build())) .withMessage("used vespene is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenTotalUsedMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearTotalUsedMinerals).build())) .withMessage("total used minerals is req... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenTotalUsedVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearTotalUsedVespene).build())) .withMessage("total used vespene is requir... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenTotalDamageDealtIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearTotalDamageDealt).build())) .withMessage("total damage dealt is requir... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenUnitTagIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(setUnitValue()) .set(DebugSetUnitValue.UnitValue.ENERGY).to(VITAL_SCORE_ENERGY).build()) .withMessage("unit tag is required"); } | public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); static DebugSetUnitValueSyntax setUnitValue(); @Override Debug.DebugSetUnitValue toSc... | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); static DebugSetUnitValueSyntax setUnitValue(); @Override Debug.DebugSetUnitValue toSc... |
@Test void throwsExceptionForNullRequest() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> aSampleS2Client().start().request((Request) nothing())) .withMessage("request is required"); } | public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Client is already stopped."); } } | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... |
@Test void throwsExceptionWhenTotalDamageTakenIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearTotalDamageTaken).build())) .withMessage("total damage taken is requir... | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void throwsExceptionWhenTotalHealedIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ScoreDetails.from(without( () -> sc2ApiScoreDetails().toBuilder(), ScoreOuterClass.ScoreDetails.Builder::clearTotalHealed).build())) .withMessage("total healed is required"); } | public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); } | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... | ScoreDetails implements Serializable { public static ScoreDetails from(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails) { require("sc2api score details", sc2ApiScoreDetails); return new ScoreDetails(sc2ApiScoreDetails); } private ScoreDetails(ScoreOuterClass.ScoreDetails sc2ApiScoreDetails); static ScoreDetails from(S... |
@Test void addsUnitToPools() { UnitPool unitPool = new UnitPool(); UnitInPool unitInPool = unitPool.createUnit(TAG); assertThatUnitInPoolIsAddedCorrectly(unitPool, unitInPool); } | UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUnitInPool); r... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... |
@Test void addsUnitToExistingPoolIfIsPresentInPool() { UnitPool unitPool = new UnitPool(); unitPool.createUnit(TAG); UnitInPool unitInPool = unitPool.createUnit(TAG); assertThatUnitInPoolIsAddedCorrectly(unitPool, unitInPool); } | UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUnitInPool); r... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... | UnitPool { UnitInPool createUnit(Tag tag) { Optional<UnitInPool> existing = getUnit(tag); if (existing.isPresent()) { UnitInPool unitInPool = existing.get(); existingPool.put(tag, unitInPool); return unitInPool; } UnitInPool newUnitInPool = new UnitInPool(tag); pool.put(tag, newUnitInPool); existingPool.put(tag, newUni... |
@Test void throwsExceptionIfOnErrorCallbackIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> new ProtoInterfaceImpl().setOnError(null)) .withMessage("onError callback is required"); } | void setOnError(BiConsumer<ClientError, List<String>> onError) { require("onError callback", onError); this.onError = onError; } | ProtoInterfaceImpl implements ProtoInterface { void setOnError(BiConsumer<ClientError, List<String>> onError) { require("onError callback", onError); this.onError = onError; } } | ProtoInterfaceImpl implements ProtoInterface { void setOnError(BiConsumer<ClientError, List<String>> onError) { require("onError callback", onError); this.onError = onError; } } | ProtoInterfaceImpl implements ProtoInterface { void setOnError(BiConsumer<ClientError, List<String>> onError) { require("onError callback", onError); this.onError = onError; } @Override boolean connectToGame(
S2Controller theGame,
Integer connectionTimeoutInMillis,
Integer requestTi... | ProtoInterfaceImpl implements ProtoInterface { void setOnError(BiConsumer<ClientError, List<String>> onError) { require("onError callback", onError); this.onError = onError; } @Override boolean connectToGame(
S2Controller theGame,
Integer connectionTimeoutInMillis,
Integer requestTi... |
@Test void startsWithUnknownGameStatus() { assertThat(new ProtoInterfaceImpl().lastStatus()).isEqualTo(GameStatus.UNKNOWN); } | @Override public GameStatus lastStatus() { return latestStatus; } | ProtoInterfaceImpl implements ProtoInterface { @Override public GameStatus lastStatus() { return latestStatus; } } | ProtoInterfaceImpl implements ProtoInterface { @Override public GameStatus lastStatus() { return latestStatus; } } | ProtoInterfaceImpl implements ProtoInterface { @Override public GameStatus lastStatus() { return latestStatus; } @Override boolean connectToGame(
S2Controller theGame,
Integer connectionTimeoutInMillis,
Integer requestTimeoutInMillis,
Boolean traced); @Override boolean c... | ProtoInterfaceImpl implements ProtoInterface { @Override public GameStatus lastStatus() { return latestStatus; } @Override boolean connectToGame(
S2Controller theGame,
Integer connectionTimeoutInMillis,
Integer requestTimeoutInMillis,
Boolean traced); @Override boolean c... |
@Test void throwsExceptionIfRequestIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> new ProtoInterfaceImpl().sendRequest((Request) null)) .withMessage("request is required"); assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> new ProtoInterfaceImpl()... | @Override public <T extends Request> Maybe<Response> sendRequest(T requestData) { require("request", requestData); if (!requestData.responseType().equals(ResponseType.PING) && responseQueue.peek(requestData.responseType())) { onError.accept(ClientError.RESPONSE_NOT_CONSUMED, Collections.emptyList()); return Maybe.empty... | ProtoInterfaceImpl implements ProtoInterface { @Override public <T extends Request> Maybe<Response> sendRequest(T requestData) { require("request", requestData); if (!requestData.responseType().equals(ResponseType.PING) && responseQueue.peek(requestData.responseType())) { onError.accept(ClientError.RESPONSE_NOT_CONSUME... | ProtoInterfaceImpl implements ProtoInterface { @Override public <T extends Request> Maybe<Response> sendRequest(T requestData) { require("request", requestData); if (!requestData.responseType().equals(ResponseType.PING) && responseQueue.peek(requestData.responseType())) { onError.accept(ClientError.RESPONSE_NOT_CONSUME... | ProtoInterfaceImpl implements ProtoInterface { @Override public <T extends Request> Maybe<Response> sendRequest(T requestData) { require("request", requestData); if (!requestData.responseType().equals(ResponseType.PING) && responseQueue.peek(requestData.responseType())) { onError.accept(ClientError.RESPONSE_NOT_CONSUME... | ProtoInterfaceImpl implements ProtoInterface { @Override public <T extends Request> Maybe<Response> sendRequest(T requestData) { require("request", requestData); if (!requestData.responseType().equals(ResponseType.PING) && responseQueue.peek(requestData.responseType())) { onError.accept(ClientError.RESPONSE_NOT_CONSUME... |
@Test void allowsToStoreOnePendingResponseTypeAtTime() { ResponseQueue responseQueue = new ResponseQueue(); assertThat(responseQueue.offer(ResponseType.ACTION, MaybeSubject.create())).isTrue(); assertThat(responseQueue.offer(ResponseType.ACTION, MaybeSubject.create())).isFalse(); } | boolean offer(ResponseType type, Maybe<Response> waitFor) { if (!pending.containsKey(type)) { if (waitFor instanceof MaybeSubject) { pending.put(type, (MaybeSubject<Response>) waitFor); return true; } else { return false; } } else { return false; } } | ResponseQueue { boolean offer(ResponseType type, Maybe<Response> waitFor) { if (!pending.containsKey(type)) { if (waitFor instanceof MaybeSubject) { pending.put(type, (MaybeSubject<Response>) waitFor); return true; } else { return false; } } else { return false; } } } | ResponseQueue { boolean offer(ResponseType type, Maybe<Response> waitFor) { if (!pending.containsKey(type)) { if (waitFor instanceof MaybeSubject) { pending.put(type, (MaybeSubject<Response>) waitFor); return true; } else { return false; } } else { return false; } } } | ResponseQueue { boolean offer(ResponseType type, Maybe<Response> waitFor) { if (!pending.containsKey(type)) { if (waitFor instanceof MaybeSubject) { pending.put(type, (MaybeSubject<Response>) waitFor); return true; } else { return false; } } else { return false; } } } | ResponseQueue { boolean offer(ResponseType type, Maybe<Response> waitFor) { if (!pending.containsKey(type)) { if (waitFor instanceof MaybeSubject) { pending.put(type, (MaybeSubject<Response>) waitFor); return true; } else { return false; } } else { return false; } } } |
@Test void throwsExceptionIfEmptyPathIsProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> new ReplaySettings().setReplayPath(null)) .withMessage("replay path is required"); } | public ReplaySettings setReplayPath(Path replayPath) throws IOException { require("replay path", replayPath); replayFiles.clear(); if (replayPath.toFile().isDirectory()) { try (Stream<Path> files = Files.walk(replayPath)) { replayFiles.addAll(files.filter(p -> !Files.isDirectory(p)).collect(Collectors.toList())); } } e... | ReplaySettings { public ReplaySettings setReplayPath(Path replayPath) throws IOException { require("replay path", replayPath); replayFiles.clear(); if (replayPath.toFile().isDirectory()) { try (Stream<Path> files = Files.walk(replayPath)) { replayFiles.addAll(files.filter(p -> !Files.isDirectory(p)).collect(Collectors.... | ReplaySettings { public ReplaySettings setReplayPath(Path replayPath) throws IOException { require("replay path", replayPath); replayFiles.clear(); if (replayPath.toFile().isDirectory()) { try (Stream<Path> files = Files.walk(replayPath)) { replayFiles.addAll(files.filter(p -> !Files.isDirectory(p)).collect(Collectors.... | ReplaySettings { public ReplaySettings setReplayPath(Path replayPath) throws IOException { require("replay path", replayPath); replayFiles.clear(); if (replayPath.toFile().isDirectory()) { try (Stream<Path> files = Files.walk(replayPath)) { replayFiles.addAll(files.filter(p -> !Files.isDirectory(p)).collect(Collectors.... | ReplaySettings { public ReplaySettings setReplayPath(Path replayPath) throws IOException { require("replay path", replayPath); replayFiles.clear(); if (replayPath.toFile().isDirectory()) { try (Stream<Path> files = Files.walk(replayPath)) { replayFiles.addAll(files.filter(p -> !Files.isDirectory(p)).collect(Collectors.... |
@Test void throwsExceptionIfEmptyFileIsProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> new ReplaySettings().loadReplayList(null)) .withMessage("file with replay list is required"); } | public ReplaySettings loadReplayList(Path path) throws IOException { require("file with replay list", path); replayFiles.clear(); try (Stream<String> lines = Files.lines(path)) { replayFiles.addAll(lines.map(Paths::get).collect(Collectors.toList())); } return this; } | ReplaySettings { public ReplaySettings loadReplayList(Path path) throws IOException { require("file with replay list", path); replayFiles.clear(); try (Stream<String> lines = Files.lines(path)) { replayFiles.addAll(lines.map(Paths::get).collect(Collectors.toList())); } return this; } } | ReplaySettings { public ReplaySettings loadReplayList(Path path) throws IOException { require("file with replay list", path); replayFiles.clear(); try (Stream<String> lines = Files.lines(path)) { replayFiles.addAll(lines.map(Paths::get).collect(Collectors.toList())); } return this; } } | ReplaySettings { public ReplaySettings loadReplayList(Path path) throws IOException { require("file with replay list", path); replayFiles.clear(); try (Stream<String> lines = Files.lines(path)) { replayFiles.addAll(lines.map(Paths::get).collect(Collectors.toList())); } return this; } ReplaySettings setReplayRecovery(b... | ReplaySettings { public ReplaySettings loadReplayList(Path path) throws IOException { require("file with replay list", path); replayFiles.clear(); try (Stream<String> lines = Files.lines(path)) { replayFiles.addAll(lines.map(Paths::get).collect(Collectors.toList())); } return this; } ReplaySettings setReplayRecovery(b... |
@Test void throwsExceptionWhenValueIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(setUnitValue().forUnit(Tag.from(UNIT_TAG)) .set(DebugSetUnitValue.UnitValue.ENERGY)).build()) .withMessage("value is required"); } | public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); } | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); static DebugSetUnitValueSyntax setUnitValue(); @Override Debug.DebugSetUnitValue toSc... | DebugSetUnitValue implements Sc2ApiSerializable<Debug.DebugSetUnitValue> { public static DebugSetUnitValueSyntax setUnitValue() { return new DebugSetUnitValue.Builder(); } private DebugSetUnitValue(DebugSetUnitValue.Builder builder); static DebugSetUnitValueSyntax setUnitValue(); @Override Debug.DebugSetUnitValue toSc... |
@Test void throwsExceptionWhenAgentListIsEmpty() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> S2Coordinator.setup().setParticipants().launchStarcraft()) .withMessage("one of agents or replay observers is required"); } | public static SettingsSyntax setup() { return new Builder(); } | S2Coordinator { public static SettingsSyntax setup() { return new Builder(); } } | S2Coordinator { public static SettingsSyntax setup() { return new Builder(); } private S2Coordinator(Builder builder); } | S2Coordinator { public static SettingsSyntax setup() { return new Builder(); } private S2Coordinator(Builder builder); void setupPorts(int numberOfAgents, Supplier<Integer> portStart, boolean checkSingle); static SettingsSyntax setup(); S2Coordinator startGame(); S2Coordinator startGame(LocalMap localMap); S2Coordinat... | S2Coordinator { public static SettingsSyntax setup() { return new Builder(); } private S2Coordinator(Builder builder); void setupPorts(int numberOfAgents, Supplier<Integer> portStart, boolean checkSingle); static SettingsSyntax setup(); S2Coordinator startGame(); S2Coordinator startGame(LocalMap localMap); S2Coordinat... |
@Test void throwsExceptionWhenOneOfDrawElementsIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ((DebugDraw.Builder) draw()).build()) .withMessage("one of draw elements is required"); } | public static DebugDrawSyntax draw() { return new Builder(); } | DebugDraw implements Sc2ApiSerializable<Debug.DebugDraw> { public static DebugDrawSyntax draw() { return new Builder(); } } | DebugDraw implements Sc2ApiSerializable<Debug.DebugDraw> { public static DebugDrawSyntax draw() { return new Builder(); } private DebugDraw(Builder builder); } | DebugDraw implements Sc2ApiSerializable<Debug.DebugDraw> { public static DebugDrawSyntax draw() { return new Builder(); } private DebugDraw(Builder builder); static DebugDrawSyntax draw(); @Override Debug.DebugDraw toSc2Api(); List<DebugText> getTexts(); List<DebugLine> getLines(); List<DebugBox> getBoxes(); List<Debu... | DebugDraw implements Sc2ApiSerializable<Debug.DebugDraw> { public static DebugDrawSyntax draw() { return new Builder(); } private DebugDraw(Builder builder); static DebugDrawSyntax draw(); @Override Debug.DebugDraw toSc2Api(); List<DebugText> getTexts(); List<DebugLine> getLines(); List<DebugBox> getBoxes(); List<Debu... |
@Test void throwsExceptionWhenUnitTagSetIsEmpty() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ((DebugSetScore.Builder) setScore()).build()) .withMessage("score is required"); } | public static DebugSetScoreSyntax setScore() { return new Builder(); } | DebugSetScore implements Sc2ApiSerializable<Debug.DebugSetScore> { public static DebugSetScoreSyntax setScore() { return new Builder(); } } | DebugSetScore implements Sc2ApiSerializable<Debug.DebugSetScore> { public static DebugSetScoreSyntax setScore() { return new Builder(); } private DebugSetScore(Builder builder); } | DebugSetScore implements Sc2ApiSerializable<Debug.DebugSetScore> { public static DebugSetScoreSyntax setScore() { return new Builder(); } private DebugSetScore(Builder builder); static DebugSetScoreSyntax setScore(); @Override Debug.DebugSetScore toSc2Api(); float getScore(); @Override boolean equals(Object o); @Overr... | DebugSetScore implements Sc2ApiSerializable<Debug.DebugSetScore> { public static DebugSetScoreSyntax setScore() { return new Builder(); } private DebugSetScore(Builder builder); static DebugSetScoreSyntax setScore(); @Override Debug.DebugSetScore toSc2Api(); float getScore(); @Override boolean equals(Object o); @Overr... |
@Test void throwsExceptionWhenResultIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ((DebugEndGame.Builder) endGame()).build()) .withMessage("result is required"); } | public static DebugEndGameSyntax endGame() { return new Builder(); } | DebugEndGame implements Sc2ApiSerializable<Debug.DebugEndGame> { public static DebugEndGameSyntax endGame() { return new Builder(); } } | DebugEndGame implements Sc2ApiSerializable<Debug.DebugEndGame> { public static DebugEndGameSyntax endGame() { return new Builder(); } private DebugEndGame(Builder builder); } | DebugEndGame implements Sc2ApiSerializable<Debug.DebugEndGame> { public static DebugEndGameSyntax endGame() { return new Builder(); } private DebugEndGame(Builder builder); static DebugEndGameSyntax endGame(); @Override Debug.DebugEndGame toSc2Api(); EndResult getResult(); @Override boolean equals(Object o); @Override... | DebugEndGame implements Sc2ApiSerializable<Debug.DebugEndGame> { public static DebugEndGameSyntax endGame() { return new Builder(); } private DebugEndGame(Builder builder); static DebugEndGameSyntax endGame(); @Override Debug.DebugEndGame toSc2Api(); EndResult getResult(); @Override boolean equals(Object o); @Override... |
@Test void throwsExceptionWhenTypeIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(createUnit()).forPlayer(PLAYER_ID).on(POS).build()) .withMessage("type is required"); } | public static DebugCreateUnitSyntax createUnit() { return new Builder(); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... |
@Test void throwsExceptionWhenOwnerIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(createUnit().ofType(Units.PROTOSS_STALKER)).on(POS).build()) .withMessage("owner is required"); } | public static DebugCreateUnitSyntax createUnit() { return new Builder(); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... |
@Test void throwsExceptionWhenPositionIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(createUnit().ofType(Units.PROTOSS_STALKER).forPlayer(PLAYER_ID)).build()) .withMessage("position is required"); } | public static DebugCreateUnitSyntax createUnit() { return new Builder(); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... |
@Test void serializesDefaultValueForQuantityIfNotProvided() { assertThat(defaultCreateUnit().getQuantity()).as("sc2api debug create unit: default quantity").isEqualTo(1); } | public int getQuantity() { return quantity; } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public int getQuantity() { return quantity; } } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public int getQuantity() { return quantity; } private DebugCreateUnit(Builder builder); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public int getQuantity() { return quantity; } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d getPosition(); int getQuantit... | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public int getQuantity() { return quantity; } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d getPosition(); int getQuantit... |
@Test void throwsExceptionWhenQuantityIsLowerThanOne() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> createUnit() .ofType(Units.PROTOSS_STALKER).forPlayer(PLAYER_ID).on(POS).withQuantity(0).build()) .withMessage("quantity has value 0 and is lower than 1"); } | public static DebugCreateUnitSyntax createUnit() { return new Builder(); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); } | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... | DebugCreateUnit implements Sc2ApiSerializable<Debug.DebugCreateUnit> { public static DebugCreateUnitSyntax createUnit() { return new Builder(); } private DebugCreateUnit(Builder builder); static DebugCreateUnitSyntax createUnit(); @Override Debug.DebugCreateUnit toSc2Api(); UnitType getType(); int getOwner(); Point2d ... |
@Test void throwsExceptionWhenColorIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(sphere().on(P0).withRadius(RADIUS)).withColor(nothing()).build()) .withMessage("color is required"); } | public static DebugSphereSyntax sphere() { return new Builder(); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... |
@Test void doesNotUseTracingIfDisabled() { DataFlowTracer tracer = mock(DataFlowTracer.class); S2Client client = aSampleS2Client().traced(false).withTracer(tracer).start(); client.request(ping()); verifyNoMoreInteractions(tracer); } | public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Client is already stopped."); } } | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... | S2Client extends DefaultSubscriber<Response> { public <T extends Request> void request(T requestData) { if (!done.get()) { require("request", requestData); if (traced) tracer.fire(requestData); channelProvider.getChannel().input(new RequestSerializer().apply(requestData)); } else { throw new IllegalStateException("Clie... |
@Test void throwsExceptionWhenCenterIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(sphere()).withRadius(RADIUS).withColor(SAMPLE_COLOR).build()) .withMessage("center is required"); } | public static DebugSphereSyntax sphere() { return new Builder(); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... |
@Test void throwsExceptionWhenRadiusIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(sphere().on(P0)).withColor(SAMPLE_COLOR).build()) .withMessage("radius is required"); } | public static DebugSphereSyntax sphere() { return new Builder(); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... |
@Test void throwsExceptionWhenRadiusIsNotGreaterThanZero() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> sphere().on(P0).withRadius(0).build()) .withMessage("radius has value 0.0 and is not greater than 0.0"); } | public static DebugSphereSyntax sphere() { return new Builder(); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); } | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... | DebugSphere implements Sc2ApiSerializable<Debug.DebugSphere> { public static DebugSphereSyntax sphere() { return new Builder(); } private DebugSphere(Builder builder); static DebugSphereSyntax sphere(); @Override Debug.DebugSphere toSc2Api(); Color getColor(); Point getCenter(); float getRadius(); @Override boolean eq... |
@Test void throwsExceptionWhenColorIsNotInValidRange() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Color.of(-1, 1, 1)) .withMessage("color [r] has value -1 and is lower than 0"); assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Color.of(256, 1, 1)) .withMessa... | public static Color of(int r, int g, int b) { return new Color(r, g, b); } | Color implements Sc2ApiSerializable<Debug.Color> { public static Color of(int r, int g, int b) { return new Color(r, g, b); } } | Color implements Sc2ApiSerializable<Debug.Color> { public static Color of(int r, int g, int b) { return new Color(r, g, b); } private Color(int r, int g, int b); } | Color implements Sc2ApiSerializable<Debug.Color> { public static Color of(int r, int g, int b) { return new Color(r, g, b); } private Color(int r, int g, int b); static Color of(int r, int g, int b); @Override Debug.Color toSc2Api(); int getR(); int getG(); int getB(); @Override boolean equals(Object o); @Override int... | Color implements Sc2ApiSerializable<Debug.Color> { public static Color of(int r, int g, int b) { return new Color(r, g, b); } private Color(int r, int g, int b); static Color of(int r, int g, int b); @Override Debug.Color toSc2Api(); int getR(); int getG(); int getB(); @Override boolean equals(Object o); @Override int... |
@Test void throwsExceptionWhenPointsAreNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Line.of(nothing(), P1)) .withMessage("p0 is required"); assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Line.of(P0, nothing())) .withMessage("p1 is required"); } | public static Line of(Point p0, Point p1) { require("p0", p0); require("p1", p1); return new Line(p0, p1); } | Line implements Sc2ApiSerializable<Debug.Line> { public static Line of(Point p0, Point p1) { require("p0", p0); require("p1", p1); return new Line(p0, p1); } } | Line implements Sc2ApiSerializable<Debug.Line> { public static Line of(Point p0, Point p1) { require("p0", p0); require("p1", p1); return new Line(p0, p1); } private Line(Point p0, Point p1); } | Line implements Sc2ApiSerializable<Debug.Line> { public static Line of(Point p0, Point p1) { require("p0", p0); require("p1", p1); return new Line(p0, p1); } private Line(Point p0, Point p1); static Line of(Point p0, Point p1); @Override Debug.Line toSc2Api(); Point getP0(); Point getP1(); @Override boolean equals(Obj... | Line implements Sc2ApiSerializable<Debug.Line> { public static Line of(Point p0, Point p1) { require("p0", p0); require("p1", p1); return new Line(p0, p1); } private Line(Point p0, Point p1); static Line of(Point p0, Point p1); @Override Debug.Line toSc2Api(); Point getP0(); Point getP1(); @Override boolean equals(Obj... |
@Test void throwsExceptionWhenColorIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> box().of(P0, P1).withColor(nothing()).build()) .withMessage("color is required"); } | public static DebugBoxSyntax box() { return new Builder(); } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); static DebugBoxSyntax box(); @Override Debug.DebugBox toSc2Api(); Color getColor(); Point getMin(); Point getMax(); @Override boolean equals(Object o); @Override int ... | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); static DebugBoxSyntax box(); @Override Debug.DebugBox toSc2Api(); Color getColor(); Point getMin(); Point getMax(); @Override boolean equals(Object o); @Override int ... |
@Test void throwsExceptionWhenMinimumIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> box().of(nothing(), P1).withColor(SAMPLE_COLOR).build()) .withMessage("min is required"); } | public static DebugBoxSyntax box() { return new Builder(); } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); static DebugBoxSyntax box(); @Override Debug.DebugBox toSc2Api(); Color getColor(); Point getMin(); Point getMax(); @Override boolean equals(Object o); @Override int ... | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); static DebugBoxSyntax box(); @Override Debug.DebugBox toSc2Api(); Color getColor(); Point getMin(); Point getMax(); @Override boolean equals(Object o); @Override int ... |
@Test void throwsExceptionWhenMaximumIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> box().of(P0, nothing()).withColor(SAMPLE_COLOR).build()) .withMessage("max is required"); } | public static DebugBoxSyntax box() { return new Builder(); } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); } | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); static DebugBoxSyntax box(); @Override Debug.DebugBox toSc2Api(); Color getColor(); Point getMin(); Point getMax(); @Override boolean equals(Object o); @Override int ... | DebugBox implements Sc2ApiSerializable<Debug.DebugBox> { public static DebugBoxSyntax box() { return new Builder(); } private DebugBox(Builder builder); static DebugBoxSyntax box(); @Override Debug.DebugBox toSc2Api(); Color getColor(); Point getMin(); Point getMax(); @Override boolean equals(Object o); @Override int ... |
@Test void throwsExceptionWhenUnitTagIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ((QueryAvailableAbilities.Builder) availableAbilities()).build()) .withMessage("unit tag is required"); } | public static QueryAvailableAbilitiesSyntax availableAbilities() { return new Builder(); } | QueryAvailableAbilities implements Sc2ApiSerializable<Query.RequestQueryAvailableAbilities> { public static QueryAvailableAbilitiesSyntax availableAbilities() { return new Builder(); } } | QueryAvailableAbilities implements Sc2ApiSerializable<Query.RequestQueryAvailableAbilities> { public static QueryAvailableAbilitiesSyntax availableAbilities() { return new Builder(); } private QueryAvailableAbilities(Builder builder); } | QueryAvailableAbilities implements Sc2ApiSerializable<Query.RequestQueryAvailableAbilities> { public static QueryAvailableAbilitiesSyntax availableAbilities() { return new Builder(); } private QueryAvailableAbilities(Builder builder); static QueryAvailableAbilitiesSyntax availableAbilities(); @Override Query.RequestQu... | QueryAvailableAbilities implements Sc2ApiSerializable<Query.RequestQueryAvailableAbilities> { public static QueryAvailableAbilitiesSyntax availableAbilities() { return new Builder(); } private QueryAvailableAbilities(Builder builder); static QueryAvailableAbilitiesSyntax availableAbilities(); @Override Query.RequestQu... |
@Test void throwsExceptionWhenAbilityIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(placeBuilding().withUnit(Tag.from(UNIT_TAG))).on(START).build()) .withMessage("ability is required"); } | public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } } | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } private QueryBuildingPlacement(Builder builder); } | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } private QueryBuildingPlacement(Builder builder); static QueryBuildingPlacementSyntax placeBuilding(); @Override Query.RequestQueryBuildingPlac... | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } private QueryBuildingPlacement(Builder builder); static QueryBuildingPlacementSyntax placeBuilding(); @Override Query.RequestQueryBuildingPlac... |
@Test void throwsExceptionWhenSc2ApiEffectDataIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> EffectData.from(nothing())) .withMessage("sc2api effect data is required"); } | public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... |
@Test void throwsExceptionWhenTargetIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(placeBuilding().withUnit(Tag.from(UNIT_TAG)) .useAbility(Abilities.BUILD_ARMORY)).build()) .withMessage("target is required"); } | public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } } | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } private QueryBuildingPlacement(Builder builder); } | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } private QueryBuildingPlacement(Builder builder); static QueryBuildingPlacementSyntax placeBuilding(); @Override Query.RequestQueryBuildingPlac... | QueryBuildingPlacement implements Sc2ApiSerializable<Query.RequestQueryBuildingPlacement> { public static QueryBuildingPlacementSyntax placeBuilding() { return new Builder(); } private QueryBuildingPlacement(Builder builder); static QueryBuildingPlacementSyntax placeBuilding(); @Override Query.RequestQueryBuildingPlac... |
@Test void throwsExceptionWhenEndIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(path().from(START)).build()) .withMessage("end is required"); } | public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } } | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } private QueryPathing(QueryPathing.Builder builder); } | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } private QueryPathing(QueryPathing.Builder builder); static QueryPathingSyntax path(); @Override Query.RequestQueryPathing toSc2Api(); Optional<Point2d> getStart(); Opti... | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } private QueryPathing(QueryPathing.Builder builder); static QueryPathingSyntax path(); @Override Query.RequestQueryPathing toSc2Api(); Optional<Point2d> getStart(); Opti... |
@Test void throwsExceptionWhenOneOfStartCaseIsNotSet() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> fullAccessTo(path()).to(END).build()) .withMessage("one of start case is required"); } | public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } } | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } private QueryPathing(QueryPathing.Builder builder); } | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } private QueryPathing(QueryPathing.Builder builder); static QueryPathingSyntax path(); @Override Query.RequestQueryPathing toSc2Api(); Optional<Point2d> getStart(); Opti... | QueryPathing implements Sc2ApiSerializable<Query.RequestQueryPathing> { public static QueryPathingSyntax path() { return new QueryPathing.Builder(); } private QueryPathing(QueryPathing.Builder builder); static QueryPathingSyntax path(); @Override Query.RequestQueryPathing toSc2Api(); Optional<Point2d> getStart(); Opti... |
@Test void throwsExceptionWhenSc2ApiBuildingPlacementIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> BuildingPlacement.from(nothing())) .withMessage("sc2api response query building placement is required"); } | public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } } | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... |
@Test void convertsAllFieldsFromSc2ApiBuildingPlacement() { assertThatAllFieldsAreConverted(BuildingPlacement.from(sc2ApiBuildingPlacement())); } | public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } } | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... |
@Test void throwsExceptionWhenTagIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> BuildingPlacement.from(without( () -> sc2ApiBuildingPlacement().toBuilder(), Query.ResponseQueryBuildingPlacement.Builder::clearResult).build())) .withMessage("result is required"); } | public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } } | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... | BuildingPlacement implements Serializable { public static BuildingPlacement from(Query.ResponseQueryBuildingPlacement sc2ApiResponseQueryBuildingPlacement) { require("sc2api response query building placement", sc2ApiResponseQueryBuildingPlacement); return new BuildingPlacement(sc2ApiResponseQueryBuildingPlacement); } p... |
@Test void throwsExceptionWhenSc2ApiAvailableAbilitiesIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> AvailableAbilities.from(nothing())) .withMessage("sc2api response query available abilities is required"); } | public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbilities(sc2ApiResponseQueryAvailableAbilities); } | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... |
@Test void convertsAllFieldsFromSc2ApiAvailableAbilities() { assertThatAllFieldsAreConverted(AvailableAbilities.from(sc2ApiAvailableAbilities())); } | public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbilities(sc2ApiResponseQueryAvailableAbilities); } | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... |
@Test void throwsExceptionWhenUnitTagIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> AvailableAbilities.from(without( () -> sc2ApiAvailableAbilities().toBuilder(), Query.ResponseQueryAvailableAbilities.Builder::clearUnitTag).build())) .withMessage("unit tag is required"); } | public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbilities(sc2ApiResponseQueryAvailableAbilities); } | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... |
@Test void throwsExceptionWhenUnitTypeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> AvailableAbilities.from(without( () -> sc2ApiAvailableAbilities().toBuilder(), Query.ResponseQueryAvailableAbilities.Builder::clearUnitTypeId).build())) .withMessage("unit type is required... | public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbilities(sc2ApiResponseQueryAvailableAbilities); } | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... | AvailableAbilities implements Serializable, GeneralizableAbility<AvailableAbilities> { public static AvailableAbilities from(Query.ResponseQueryAvailableAbilities sc2ApiResponseQueryAvailableAbilities) { require("sc2api response query available abilities", sc2ApiResponseQueryAvailableAbilities); return new AvailableAbi... |
@Test void convertsAllFieldsFromSc2ApiUnit() { assertThatAllFieldsAreConverted(EffectData.from(sc2ApiEffectData())); } | public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... |
@Test void throwsExceptionWhenSc2ApiPathingIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Pathing.from(nothing())) .withMessage("sc2api response query pathing is required"); } | public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } } | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } private Pathing(Query.ResponseQueryPathing sc2ApiResponseQueryPathing); } | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } private Pathing(Query.ResponseQueryPathing sc2ApiResponseQueryPathing); static Pa... | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } private Pathing(Query.ResponseQueryPathing sc2ApiResponseQueryPathing); static Pa... |
@Test void convertsAllFieldsFromSc2ApiPathing() { assertThatAllFieldsAreConverted(Pathing.from(sc2ApiPathing())); } | public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } } | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } private Pathing(Query.ResponseQueryPathing sc2ApiResponseQueryPathing); } | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } private Pathing(Query.ResponseQueryPathing sc2ApiResponseQueryPathing); static Pa... | Pathing implements Serializable { public static Pathing from(Query.ResponseQueryPathing sc2ApiResponseQueryPathing) { require("sc2api response query pathing", sc2ApiResponseQueryPathing); return new Pathing(sc2ApiResponseQueryPathing); } private Pathing(Query.ResponseQueryPathing sc2ApiResponseQueryPathing); static Pa... |
@Test void providesInformationAboutGameVersions() { assertThat(Versions.versionFor(BASE_BUILD)).isNotEmpty(); } | public static Optional<GameVersion> versionFor(int baseBuild) { return Optional.ofNullable(gameVersions.get(baseBuild)); } | Versions { public static Optional<GameVersion> versionFor(int baseBuild) { return Optional.ofNullable(gameVersions.get(baseBuild)); } } | Versions { public static Optional<GameVersion> versionFor(int baseBuild) { return Optional.ofNullable(gameVersions.get(baseBuild)); } private Versions(); } | Versions { public static Optional<GameVersion> versionFor(int baseBuild) { return Optional.ofNullable(gameVersions.get(baseBuild)); } private Versions(); static Optional<GameVersion> versionFor(int baseBuild); } | Versions { public static Optional<GameVersion> versionFor(int baseBuild) { return Optional.ofNullable(gameVersions.get(baseBuild)); } private Versions(); static Optional<GameVersion> versionFor(int baseBuild); static final String API_VERSION; } |
@Test void throwsExceptionWhenSc2ApiObservationIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Observation.from(nothing())) .withMessage("sc2api observation is required"); } | public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... |
@Test void convertsAllFieldsFromSc2ApiObservation() { assertThatAllFieldsAreConverted(Observation.from(sc2ApiObservation())); } | public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... |
@Test void throwsExceptionWhenGameLoopIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Observation.from(without( () -> sc2ApiObservation().toBuilder(), Sc2Api.Observation.Builder::clearGameLoop).build())) .withMessage("game loop is required"); } | public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... |
@Test void throwsExceptionWhenPlayerCommonIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Observation.from(without( () -> sc2ApiObservation().toBuilder(), Sc2Api.Observation.Builder::clearPlayerCommon).build())) .withMessage("player common is required"); } | public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... |
@Test void throwsExceptionWhenOneOfInterfacesNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Observation.from(without( () -> sc2ApiObservation().toBuilder(), Sc2Api.Observation.Builder::clearRawData, Sc2Api.Observation.Builder::clearFeatureLayerData, Sc2Api.Observation.Builde... | public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... |
@Test void fulfillsEqualsContract() throws UnsupportedEncodingException { EqualsVerifier .forClass(Observation.class) .withNonnullFields("playerCommon", "alerts", "availableAbilities") .withPrefabValues(UnitInfo.class, UnitInfo.from(sc2ApiUnitInfoAddOn()), UnitInfo.from(sc2ApiUnitInfo())) .withPrefabValues( ByteString.... | public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); } | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... | Observation implements Serializable { public static Observation from(Sc2Api.Observation sc2ApiObservation) { require("sc2api observation", sc2ApiObservation); return new Observation(sc2ApiObservation); } private Observation(Sc2Api.Observation sc2ApiObservation); static Observation from(Sc2Api.Observation sc2ApiObserva... |
@Test void throwsExceptionWhenSc2ApiAvailableAbilityIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> AvailableAbility.from(nothing())) .withMessage("sc2api available ability is required"); } | public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } } | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... |
@Test void throwsExceptionWhenEffectIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> EffectData.from(without( () -> sc2ApiEffectData().toBuilder(), Data.EffectData.Builder::clearEffectId).build())) .withMessage("effect is required"); } | public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... |
@Test void convertsAllFieldsFromSc2ApiAvailableAbility() { assertThatAllFieldsAreConverted(AvailableAbility.from(sc2ApiAvailableAbility())); } | public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } } | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... |
@Test void throwsExceptionWhenAbilityIdIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> AvailableAbility.from(without( () -> sc2ApiAvailableAbility().toBuilder(), Common.AvailableAbility.Builder::clearAbilityId).build())) .withMessage("ability is required"); } | public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } } | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... | AvailableAbility implements Serializable, GeneralizableAbility<AvailableAbility> { public static AvailableAbility from(Common.AvailableAbility sc2ApiAvailableAbility) { require("sc2api available ability", sc2ApiAvailableAbility); return new AvailableAbility(sc2ApiAvailableAbility); } private AvailableAbility(Common.Av... |
@Test void throwsExceptionWhenSc2ApiFeatureLayersMinimapIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayersMinimap.from(nothing())) .withMessage("sc2api feature layers minimap is required"); } | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void convertsAllFieldsFromSc2ApiFeatureLayersMinimap() { assertThatAllFieldsAreConverted(FeatureLayersMinimap.from(sc2ApiFeatureLayersMinimap())); } | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void throwsExceptionWhenHeightMapIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayersMinimap.from(without( () -> sc2ApiFeatureLayersMinimap().toBuilder(), Spatial.FeatureLayersMinimap.Builder::clearHeightMap).build())) .withMessage("height map is required"); ... | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void throwsExceptionWhenVisibilityMapIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayersMinimap.from(without( () -> sc2ApiFeatureLayersMinimap().toBuilder(), Spatial.FeatureLayersMinimap.Builder::clearVisibilityMap).build())) .withMessage("visibility map is ... | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void throwsExceptionWhenCreepIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayersMinimap.from(without( () -> sc2ApiFeatureLayersMinimap().toBuilder(), Spatial.FeatureLayersMinimap.Builder::clearCreep).build())) .withMessage("creep is required"); } | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void throwsExceptionWhenCameraIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayersMinimap.from(without( () -> sc2ApiFeatureLayersMinimap().toBuilder(), Spatial.FeatureLayersMinimap.Builder::clearCamera).build())) .withMessage("camera is required"); } | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void throwsExceptionWhenPlayerIdIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayersMinimap.from(without( () -> sc2ApiFeatureLayersMinimap().toBuilder(), Spatial.FeatureLayersMinimap.Builder::clearPlayerId).build())) .withMessage("player id is required"); } | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void throwsExceptionWhenSelectedIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayersMinimap.from(without( () -> sc2ApiFeatureLayersMinimap().toBuilder(), Spatial.FeatureLayersMinimap.Builder::clearSelected).build())) .withMessage("selected is required"); } | public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } } | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... | FeatureLayersMinimap implements Serializable { public static FeatureLayersMinimap from(Spatial.FeatureLayersMinimap sc2ApiFeatureLayersMinimap) { require("sc2api feature layers minimap", sc2ApiFeatureLayersMinimap); return new FeatureLayersMinimap(sc2ApiFeatureLayersMinimap); } private FeatureLayersMinimap(Spatial.Fea... |
@Test void throwsExceptionWhenNameIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> EffectData.from(without( () -> sc2ApiEffectData().toBuilder(), Data.EffectData.Builder::clearName).build())) .withMessage("name is required"); } | public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); } | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... | EffectData implements Serializable { public static EffectData from(Data.EffectData sc2ApiEffectData) { require("sc2api effect data", sc2ApiEffectData); return new EffectData(sc2ApiEffectData); } private EffectData(Data.EffectData sc2ApiEffectData); static EffectData from(Data.EffectData sc2ApiEffectData); Effect getEf... |
@Test public void parseContainerIdFromHostname() { assertThat(RecommendationVerticle.parseContainerIdFromHostname("recommendation-v1-abcdef"), equalTo("abcdef")); assertThat(RecommendationVerticle.parseContainerIdFromHostname("recommendation-v2-abcdef"), equalTo("abcdef")); assertThat(RecommendationVerticle.parseContai... | static String parseContainerIdFromHostname(String hostname) { return hostname.replaceAll("recommendation-v\\d+-", ""); } | RecommendationVerticle extends AbstractVerticle { static String parseContainerIdFromHostname(String hostname) { return hostname.replaceAll("recommendation-v\\d+-", ""); } } | RecommendationVerticle extends AbstractVerticle { static String parseContainerIdFromHostname(String hostname) { return hostname.replaceAll("recommendation-v\\d+-", ""); } } | RecommendationVerticle extends AbstractVerticle { static String parseContainerIdFromHostname(String hostname) { return hostname.replaceAll("recommendation-v\\d+-", ""); } @Override void start(); static void main(String[] args); } | RecommendationVerticle extends AbstractVerticle { static String parseContainerIdFromHostname(String hostname) { return hostname.replaceAll("recommendation-v\\d+-", ""); } @Override void start(); static void main(String[] args); } |
@Test public void testMatchFirst() { List<Integer> res = textAndPosition.match("bc"); assertEquals(Arrays.asList(10), res); } | public List<Integer> match(String toMatch) { toMatch = toMatch.toLowerCase(); ArrayList<Integer> result= new ArrayList<>(); if (toMatch.length() == 0) return result; int found = 0; while ((found = content.indexOf(toMatch, found)) != -1 ) { int actualPos = convertIndexToPos(found); result.add(actualPos); found++; } retu... | TextAndPosition { public List<Integer> match(String toMatch) { toMatch = toMatch.toLowerCase(); ArrayList<Integer> result= new ArrayList<>(); if (toMatch.length() == 0) return result; int found = 0; while ((found = content.indexOf(toMatch, found)) != -1 ) { int actualPos = convertIndexToPos(found); result.add(actualPos... | TextAndPosition { public List<Integer> match(String toMatch) { toMatch = toMatch.toLowerCase(); ArrayList<Integer> result= new ArrayList<>(); if (toMatch.length() == 0) return result; int found = 0; while ((found = content.indexOf(toMatch, found)) != -1 ) { int actualPos = convertIndexToPos(found); result.add(actualPos... | TextAndPosition { public List<Integer> match(String toMatch) { toMatch = toMatch.toLowerCase(); ArrayList<Integer> result= new ArrayList<>(); if (toMatch.length() == 0) return result; int found = 0; while ((found = content.indexOf(toMatch, found)) != -1 ) { int actualPos = convertIndexToPos(found); result.add(actualPos... | TextAndPosition { public List<Integer> match(String toMatch) { toMatch = toMatch.toLowerCase(); ArrayList<Integer> result= new ArrayList<>(); if (toMatch.length() == 0) return result; int found = 0; while ((found = content.indexOf(toMatch, found)) != -1 ) { int actualPos = convertIndexToPos(found); result.add(actualPos... |
@Test public void testSimple() throws MDCSyntaxError { String mdc = "i-w-r:a-C1-m-pt:p*t"; MDCCodeExtractor extractor= new MDCCodeExtractor(); List<String> codeList = extractor.getCodesAsList(mdc); assertEquals(Arrays.asList("M17","G43","D21","D36","C1", "G17", "N1", "Q3", "X1"), codeList); } | public List<String> getCodesAsList(String manuelDeCodageText) throws MDCSyntaxError { SignListBuilder builder = new SignListBuilder(); MDCParserFacade parser = new MDCParserFacade(builder); parser.parse(new StringReader(manuelDeCodageText)); return builder.result; } | MDCCodeExtractor { public List<String> getCodesAsList(String manuelDeCodageText) throws MDCSyntaxError { SignListBuilder builder = new SignListBuilder(); MDCParserFacade parser = new MDCParserFacade(builder); parser.parse(new StringReader(manuelDeCodageText)); return builder.result; } } | MDCCodeExtractor { public List<String> getCodesAsList(String manuelDeCodageText) throws MDCSyntaxError { SignListBuilder builder = new SignListBuilder(); MDCParserFacade parser = new MDCParserFacade(builder); parser.parse(new StringReader(manuelDeCodageText)); return builder.result; } } | MDCCodeExtractor { public List<String> getCodesAsList(String manuelDeCodageText) throws MDCSyntaxError { SignListBuilder builder = new SignListBuilder(); MDCParserFacade parser = new MDCParserFacade(builder); parser.parse(new StringReader(manuelDeCodageText)); return builder.result; } String[] getCodes(String manuelDe... | MDCCodeExtractor { public List<String> getCodesAsList(String manuelDeCodageText) throws MDCSyntaxError { SignListBuilder builder = new SignListBuilder(); MDCParserFacade parser = new MDCParserFacade(builder); parser.parse(new StringReader(manuelDeCodageText)); return builder.result; } String[] getCodes(String manuelDe... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.