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 throwsExceptionWhenSc2ApiObservationRenderIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ObservationRender.from(nothing())) .withMessage("sc2api observation render is required"); } | public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... |
@Test void convertsAllFieldsFromSc2ApiObservationRender() { assertThatAllFieldsAreConverted(ObservationRender.from(sc2ApiObservationRender())); } | public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... |
@Test void throwsExceptionWhenMapIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ObservationRender.from(without( () -> sc2ApiObservationRender().toBuilder(), Spatial.ObservationRender.Builder::clearMap).build())) .withMessage("map is required"); } | public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... |
@Test void throwsExceptionWhenMinimapIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ObservationRender.from(without( () -> sc2ApiObservationRender().toBuilder(), Spatial.ObservationRender.Builder::clearMinimap).build())) .withMessage("minimap is required"); } | public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } } | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... | ObservationRender implements Serializable { public static ObservationRender from(Spatial.ObservationRender sc2ApiObservationRender) { require("sc2api observation render", sc2ApiObservationRender); return new ObservationRender(sc2ApiObservationRender); } private ObservationRender(Spatial.ObservationRender sc2ApiObserva... |
@Test void throwsExceptionWhenSc2ApiFeatureLayersIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(nothing())) .withMessage("sc2api feature layers is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void convertsAllFieldsFromSc2ApiFeatureLayers() { assertThatAllFieldsAreConverted(FeatureLayers.from(sc2ApiFeatureLayers())); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenHeightMapIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearHeightMap).build())) .withMessage("height map is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenVisibilityMapIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearVisibilityMap).build())) .withMessage("visibility map is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenRadiusIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> EffectData.from(without( () -> sc2ApiEffectData().toBuilder(), Data.EffectData.Builder::clearRadius).build())) .withMessage("radius 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 throwsExceptionWhenCreepIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearCreep).build())) .withMessage("creep is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenPowerIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearPower).build())) .withMessage("power is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenPlayerIdIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearPlayerId).build())) .withMessage("player id is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenUnitTypeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearUnitType).build())) .withMessage("unit type is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenSelectedIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearSelected).build())) .withMessage("selected is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenUnitHitPointsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearUnitHitPoints).build())) .withMessage("unit hit points is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenUnitHitPointsRatioIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearUnitHitPointsRatio).build())) .withMessage("unit hit points ratio is requ... | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenUnitEnergyIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearUnitEnergy).build())) .withMessage("unit energy is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenUnitShieldsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearUnitShields).build())) .withMessage("unit shields is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenPlayerRelativeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearPlayerRelative).build())) .withMessage("player relative is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenSc2ApiDamageBonusIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> DamageBonus.from(nothing())) .withMessage("sc2api damage bonus is required"); } | public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... |
@Test void throwsExceptionWhenUnitDensityAaIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearUnitDensityAa).build())) .withMessage("unit density aa is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenUnitDensityIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> FeatureLayers.from(without( () -> sc2ApiFeatureLayers().toBuilder(), Spatial.FeatureLayers.Builder::clearUnitDensity).build())) .withMessage("unit density is required"); } | public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); } | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... | FeatureLayers implements Serializable { public static FeatureLayers from(Spatial.FeatureLayers sc2ApiFeatureLayers) { require("sc2api feature layers", sc2ApiFeatureLayers); return new FeatureLayers(sc2ApiFeatureLayers); } private FeatureLayers(Spatial.FeatureLayers sc2ApiFeatureLayers); static FeatureLayers from(Spati... |
@Test void throwsExceptionWhenSc2ApiMultiPanelIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> MultiPanel.from(nothing())) .withMessage("sc2api multi panel is required"); } | public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel); List<UnitInfo> get... | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel); List<UnitInfo> get... |
@Test void convertsAllFieldsFromSc2ApiMultiPanel() { assertThatAllFieldsAreConverted(MultiPanel.from(sc2ApiMultiPanel())); } | public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel); List<UnitInfo> get... | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel); List<UnitInfo> get... |
@Test void fulfillsEqualsContract() { EqualsVerifier .forClass(MultiPanel.class) .withNonnullFields("units") .withPrefabValues(UnitInfo.class, UnitInfo.from(sc2ApiUnitInfoAddOn()), UnitInfo.from(sc2ApiUnitInfo())) .verify(); } | public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); } | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel); List<UnitInfo> get... | MultiPanel implements Serializable { public static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel) { require("sc2api multi panel", sc2ApiMultiPanel); return new MultiPanel(sc2ApiMultiPanel); } private MultiPanel(Ui.MultiPanel sc2ApiMultiPanel); static MultiPanel from(Ui.MultiPanel sc2ApiMultiPanel); List<UnitInfo> get... |
@Test void throwsExceptionWhenSc2ApiSinglePanelIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> SinglePanel.from(nothing())) .withMessage("sc2api single panel is required"); } | public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... |
@Test void convertsAllFieldsFromSc2ApiSinglePanel() { assertThatAllFieldsAreConverted(SinglePanel.from(sc2ApiSinglePanel())); } | public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... |
@Test void throwsExceptionWhenTagIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> SinglePanel.from( without(() -> sc2ApiSinglePanel().toBuilder(), Ui.SinglePanel.Builder::clearUnit).build())) .withMessage("unit is required"); } | public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... |
@Test void fulfillsEqualsContract() { EqualsVerifier .forClass(SinglePanel.class) .withNonnullFields("unit", "buffs") .withPrefabValues(UnitInfo.class, UnitInfo.from(sc2ApiUnitInfoAddOn()), UnitInfo.from(sc2ApiUnitInfo())) .verify(); } | public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); } | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... | SinglePanel implements Serializable { public static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel) { require("sc2api single panel", sc2ApiSinglePanel); return new SinglePanel(sc2ApiSinglePanel); } private SinglePanel(Ui.SinglePanel sc2ApiSinglePanel); static SinglePanel from(Ui.SinglePanel sc2ApiSinglePanel); Unit... |
@Test void throwsExceptionWhenSc2ApiProductionPanelIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ProductionPanel.from(nothing())) .withMessage("sc2api production panel is required"); } | public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... |
@Test void convertsAllFieldsFromSc2ApiDamageBonus() { assertThatAllFieldsAreConverted(DamageBonus.from(sc2ApiDamageBonus())); } | public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... |
@Test void convertsAllFieldsFromSc2ApiProductionPanel() { assertThatAllFieldsAreConverted(ProductionPanel.from(sc2ApiProductionPanel())); } | public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... |
@Test void throwsExceptionWhenUnitIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ProductionPanel.from(without( () -> sc2ApiProductionPanel().toBuilder(), Ui.ProductionPanel.Builder::clearUnit).build())) .withMessage("unit is required"); } | public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... |
@Test void fulfillsEqualsContract() { EqualsVerifier .forClass(ProductionPanel.class) .withNonnullFields("unit", "buildQueue", "productionQueue") .withPrefabValues(UnitInfo.class, UnitInfo.from(sc2ApiUnitInfoAddOn()), UnitInfo.from(sc2ApiUnitInfo())) .verify(); } | public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); } | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... | ProductionPanel implements Serializable { public static ProductionPanel from(Ui.ProductionPanel sc2ApiProductionPanel) { require("sc2api production panel", sc2ApiProductionPanel); return new ProductionPanel(sc2ApiProductionPanel); } private ProductionPanel(Ui.ProductionPanel sc2ApiProductionPanel); static ProductionPa... |
@Test void throwsExceptionWhenSc2ApiControlGroupIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ControlGroup.from(nothing())) .withMessage("sc2api control group is required"); } | public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... |
@Test void convertsSc2ApiControlGroupToControlGroup() { assertThatAllFieldsAreConverted(ControlGroup.from(sc2ApiControlGroup())); } | public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... |
@Test void throwsExceptionWhenIndexIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ControlGroup.from(without( () -> sc2ApiControlGroup().toBuilder(), Ui.ControlGroup.Builder::clearControlGroupIndex).build())) .withMessage("index is required"); } | public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... |
@Test void throwsExceptionWhenLeaderUnitTypeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ControlGroup.from(without( () -> sc2ApiControlGroup().toBuilder(), Ui.ControlGroup.Builder::clearLeaderUnitType).build())) .withMessage("leader unit type is required"); } | public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... |
@Test void throwsExceptionWhenCountIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ControlGroup.from(without( () -> sc2ApiControlGroup().toBuilder(), Ui.ControlGroup.Builder::clearCount).build())) .withMessage("count is required"); } | public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); } | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... | ControlGroup implements Serializable { public static ControlGroup from(Ui.ControlGroup sc2ApiControlGroup) { require("sc2api control group", sc2ApiControlGroup); return new ControlGroup(sc2ApiControlGroup); } private ControlGroup(Ui.ControlGroup sc2ApiControlGroup); static ControlGroup from(Ui.ControlGroup sc2ApiContr... |
@Test void throwsExceptionWhenSc2ApiCargoPanelIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> CargoPanel.from(nothing())) .withMessage("sc2api cargo panel is required"); } | public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... |
@Test void convertsAllFieldsFromSc2ApiCargoPanel() { assertThatAllFieldsAreConverted(CargoPanel.from(sc2ApiCargoPanel())); } | public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... |
@Test void throwsExceptionWhenAttributeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> DamageBonus.from(without( () -> sc2ApiDamageBonus().toBuilder(), Data.DamageBonus.Builder::clearAttribute).build())) .withMessage("attribute is required"); } | public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... |
@Test void throwsExceptionWhenUnitIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> CargoPanel.from( without(() -> sc2ApiCargoPanel().toBuilder(), Ui.CargoPanel.Builder::clearUnit).build())) .withMessage("unit is required"); } | public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... |
@Test void throwsExceptionWhenCargoSizeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> CargoPanel.from(without( () -> sc2ApiCargoPanel().toBuilder(), Ui.CargoPanel.Builder::clearSlotsAvailable).build())) .withMessage("cargo size is required"); } | public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... |
@Test void fulfillsEqualsContract() { EqualsVerifier .forClass(CargoPanel.class) .withNonnullFields("unit", "passengers") .withPrefabValues(UnitInfo.class, UnitInfo.from(sc2ApiUnitInfoAddOn()), UnitInfo.from(sc2ApiUnitInfo())) .verify(); } | public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); } | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... | CargoPanel implements Serializable { public static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel) { require("sc2api cargo panel", sc2ApiCargoPanel); return new CargoPanel(sc2ApiCargoPanel); } private CargoPanel(Ui.CargoPanel sc2ApiCargoPanel); static CargoPanel from(Ui.CargoPanel sc2ApiCargoPanel); UnitInfo getUnit()... |
@Test void throwsExceptionWhenSc2ApiObservationUiIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ObservationUi.from(nothing())) .withMessage("sc2api observation ui is required"); } | public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); static ObservationUi from(Ui.ObservationU... | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); static ObservationUi from(Ui.ObservationU... |
@Test void convertsAllFieldsFromSc2ApiObservationUi() { assertThatAllFieldsAreConvertedForSinglePanel(ObservationUi.from(sc2ApiObservationUiSingle())); assertThatAllFieldsAreConvertedForMultiPanel(ObservationUi.from(sc2ApiObservationUiMulti())); assertThatAllFieldsAreConvertedForCargoPanel(ObservationUi.from(sc2ApiObse... | public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); static ObservationUi from(Ui.ObservationU... | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); static ObservationUi from(Ui.ObservationU... |
@Test void fulfillsEqualsContract() { EqualsVerifier .forClass(ObservationUi.class) .withNonnullFields("controlGroups") .withPrefabValues(UnitInfo.class, UnitInfo.from(sc2ApiUnitInfoAddOn()), UnitInfo.from(sc2ApiUnitInfo())) .verify(); } | public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); } | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); static ObservationUi from(Ui.ObservationU... | ObservationUi implements Serializable { public static ObservationUi from(Ui.ObservationUI sc2ApiObservationUi) { require("sc2api observation ui", sc2ApiObservationUi); return new ObservationUi(sc2ApiObservationUi); } private ObservationUi(Ui.ObservationUI sc2ApiObservationUi); static ObservationUi from(Ui.ObservationU... |
@Test void throwsExceptionWhenSc2ApiBuildItemIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> BuildItem.from(nothing())) .withMessage("sc2api build item is required"); } | public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... |
@Test void convertsAllFieldsFromSc2ApiBuildItem() { assertThatAllFieldsAreConverted(BuildItem.from(sc2ApiBuildItem())); } | public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... |
@Test void throwsExceptionWhenAbilityIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> BuildItem.from( without(() -> sc2ApiBuildItem().toBuilder(), Ui.BuildItem.Builder::clearAbilityId).build())) .withMessage("ability is required"); } | public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... |
@Test void throwsExceptionWhenBuildProgressIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> BuildItem.from( without(() -> sc2ApiBuildItem().toBuilder(), Ui.BuildItem.Builder::clearBuildProgress).build())) .withMessage("build progress is required"); } | public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); } | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... | BuildItem implements Serializable { public static BuildItem from(Ui.BuildItem sc2ApiBuildItem) { require("sc2api build item", sc2ApiBuildItem); return new BuildItem(sc2ApiBuildItem); } private BuildItem(Ui.BuildItem sc2ApiBuildItem); static BuildItem from(Ui.BuildItem sc2ApiBuildItem); Ability getAbility(); float getB... |
@Test void throwsExceptionWhenBonusIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> DamageBonus.from(without( () -> sc2ApiDamageBonus().toBuilder(), Data.DamageBonus.Builder::clearBonus).build())) .withMessage("bonus is required"); } | public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); } | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... | DamageBonus implements Serializable { public static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus) { require("sc2api damage bonus", sc2ApiDamageBonus); return new DamageBonus(sc2ApiDamageBonus); } private DamageBonus(Data.DamageBonus sc2ApiDamageBonus); static DamageBonus from(Data.DamageBonus sc2ApiDamageBonus)... |
@Test void throwsExceptionWhenSc2ApiPlayerCommonIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(nothing())) .withMessage("sc2api player common is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void convertsAllFieldsFromSc2ApiPlayerCommon() { assertThatAllFieldsAreConverted(PlayerCommon.from(sc2ApiPlayerCommon())); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenPlayerIdIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearPlayerId).build())) .withMessage("player id is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenMineralsIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearMinerals).build())) .withMessage("minerals is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenVespeneIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearVespene).build())) .withMessage("vespene is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenFoodCapIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearFoodCap).build())) .withMessage("food cap is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenFoodUsedIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearFoodUsed).build())) .withMessage("food used is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenFoodArmyIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearFoodArmy).build())) .withMessage("food army is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenFoodWorkersIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearFoodWorkers).build())) .withMessage("food workers is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenIdleWorkerCountIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearIdleWorkerCount).build())) .withMessage("idle worker count is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenSc2ApiUnitTypeDataIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> UnitTypeData.from(nothing())) .withMessage("sc2api unit type data is required"); } | public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... |
@Test void throwsExceptionWhenArmyCountIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerCommon.from(without( () -> sc2ApiPlayerCommon().toBuilder(), Sc2Api.PlayerCommon.Builder::clearArmyCount).build())) .withMessage("army count is required"); } | public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); } | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... | PlayerCommon implements Serializable { public static PlayerCommon from(Sc2Api.PlayerCommon sc2ApiPlayerCommon) { require("sc2api player common", sc2ApiPlayerCommon); return new PlayerCommon(sc2ApiPlayerCommon); } private PlayerCommon(Sc2Api.PlayerCommon sc2ApiPlayerCommon); static PlayerCommon from(Sc2Api.PlayerCommon... |
@Test void throwsExceptionWhenSc2ApiChatReceivedIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ChatReceived.from(nothing())) .withMessage("sc2api chat received is required"); } | public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... |
@Test void convertsSc2ApiChatReceivedToChatReceived() { assertThatAllFieldsAreConverted(ChatReceived.from(sc2ApiChatReceived())); } | public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... |
@Test void throwsExceptionWhenPlayerIdInNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ChatReceived.from(sc2ApiChatReceivedWithoutPlayerId())) .withMessage("player id is required"); } | public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... |
@Test void throwsExceptionWhenMessageInNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ChatReceived.from(sc2ApiChatReceivedWithoutMessage())) .withMessage("message is required"); } | public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); } | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... | ChatReceived implements Serializable { public static ChatReceived from(Sc2Api.ChatReceived sc2ApiChatReceived) { require("sc2api chat received", sc2ApiChatReceived); return new ChatReceived(sc2ApiChatReceived); } private ChatReceived(Sc2Api.ChatReceived sc2ApiChatReceived); static ChatReceived from(Sc2Api.ChatReceived... |
@Test void throwsExceptionWhenSc2ApiPlayerResultIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerResult.from(nothing())) .withMessage("sc2api player result is required"); } | public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... |
@Test void convertsAllFieldsFromSc2ApiPlayerResult() { assertThatAllFieldsAreConverted(PlayerResult.from(sc2ApiPlayerResult())); } | public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... |
@Test void throwsExceptionWhenSc2ApiPlayerInfoDoesNotExist() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerResult.from(sc2ApiPlayerResultWithoutPlayerId())) .withMessage("player id is required"); } | public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... |
@Test void throwsExceptionWhenSc2ApiResultDoesNotExist() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerResult.from(sc2PlayerResultWithoutResult())) .withMessage("result is required"); } | public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); } | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... | PlayerResult implements Serializable { public static PlayerResult from(Sc2Api.PlayerResult sc2ApiPlayerResult) { require("sc2api player result", sc2ApiPlayerResult); return new PlayerResult(sc2ApiPlayerResult); } private PlayerResult(Sc2Api.PlayerResult sc2ApiPlayerResult); static PlayerResult from(Sc2Api.PlayerResult... |
@Test void throwsExceptionWhenSc2ApiMapStateIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> MapState.from(nothing())) .withMessage("sc2api map state is required"); } | public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... |
@Test void convertsAllFieldsFromSc2ApiUnit() { assertThatAllFieldsAreConverted(UnitTypeData.from(sc2ApiUnitTypeData())); } | public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... |
@Test void convertsAllFieldsFromSc2ApiMapState() { assertThatAllFieldsAreConverted(MapState.from(sc2ApiMapState())); } | public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... |
@Test void throwsExceptionWhenVisibilityIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> MapState.from(without( () -> sc2ApiMapState().toBuilder(), Raw.MapState.Builder::clearVisibility).build())) .withMessage("visibility is required"); } | public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... |
@Test void throwsExceptionWhenCreepIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> MapState.from(without( () -> sc2ApiMapState().toBuilder(), Raw.MapState.Builder::clearCreep).build())) .withMessage("creep is required"); } | public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); } | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... | MapState implements Serializable { public static MapState from(Raw.MapState sc2ApiMapState) { require("sc2api map state", sc2ApiMapState); return new MapState(sc2ApiMapState); } private MapState(Raw.MapState sc2ApiMapState); static MapState from(Raw.MapState sc2ApiMapState); ImageData getVisibility(); ImageData getCre... |
@Test void throwsExceptionWhenSc2ApiObservationRawIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ObservationRaw.from(nothing())) .withMessage("sc2api observation raw is required"); } | public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... |
@Test void convertsAllFieldsFromSc2ApiObservationRaw() { assertThatAllFieldsAreConverted(ObservationRaw.from(sc2ApiObservationRaw())); } | public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... |
@Test void throwsExceptionWhenPlayerIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ObservationRaw.from(without( () -> sc2ApiObservationRaw().toBuilder(), Raw.ObservationRaw.Builder::clearPlayer).build())) .withMessage("player is required"); } | public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... |
@Test void throwsExceptionWhenMapStateIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> ObservationRaw.from(without( () -> sc2ApiObservationRaw().toBuilder(), Raw.ObservationRaw.Builder::clearMapState).build())) .withMessage("map state is required"); } | public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); } | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... | ObservationRaw implements Serializable { public static ObservationRaw from(Raw.ObservationRaw sc2ApiObservationRaw) { require("sc2api observation raw", sc2ApiObservationRaw); return new ObservationRaw(sc2ApiObservationRaw); } private ObservationRaw(Raw.ObservationRaw sc2ApiObservationRaw); static ObservationRaw from(R... |
@Test void throwsExceptionWhenSc2ApiPlayerRawIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerRaw.from(nothing())) .withMessage("sc2api player raw is required"); } | public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw); Set<PowerSource> getPowerSour... | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw); Set<PowerSource> getPowerSour... |
@Test void convertsAllFieldsFromSc2ApiPlayerRaw() { assertThatAllFieldsAreConverted(PlayerRaw.from(sc2ApiPlayerRaw())); } | public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw); Set<PowerSource> getPowerSour... | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw); Set<PowerSource> getPowerSour... |
@Test void throwsExceptionWhenCameraIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PlayerRaw.from(without( () -> sc2ApiPlayerRaw().toBuilder(), Raw.PlayerRaw.Builder::clearCamera).build())) .withMessage("camera is required"); } | public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); } | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw); Set<PowerSource> getPowerSour... | PlayerRaw implements Serializable { public static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw) { require("sc2api player raw", sc2ApiPlayerRaw); return new PlayerRaw(sc2ApiPlayerRaw); } private PlayerRaw(Raw.PlayerRaw sc2ApiPlayerRaw); static PlayerRaw from(Raw.PlayerRaw sc2ApiPlayerRaw); Set<PowerSource> getPowerSour... |
@Test void throwsExceptionWhenUnitTypeIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> UnitTypeData.from(without( () -> sc2ApiUnitTypeData().toBuilder(), Data.UnitTypeData.Builder::clearUnitId).build())) .withMessage("unit type is required"); } | public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... |
@Test void throwsExceptionWhenSc2ApiPowerSourceIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PowerSource.from(nothing())) .withMessage("sc2api power source is required"); } | public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... |
@Test void convertsAllFieldsFromSc2ApiPowerSource() { assertThatAllFieldsAreConverted(PowerSource.from(sc2ApiPowerSource())); } | public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... |
@Test void throwsExceptionWhenPositionIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PowerSource.from(without( () -> sc2ApiPowerSource().toBuilder(), Raw.PowerSource.Builder::clearPos).build())) .withMessage("position is required"); } | public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... |
@Test void throwsExceptionWhenRadiusIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PowerSource.from(without( () -> sc2ApiPowerSource().toBuilder(), Raw.PowerSource.Builder::clearRadius).build())) .withMessage("radius is required"); } | public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... |
@Test void throwsExceptionWhenTagIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> PowerSource.from(without( () -> sc2ApiPowerSource().toBuilder(), Raw.PowerSource.Builder::clearTag).build())) .withMessage("tag is required"); } | public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); } | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... | PowerSource implements Serializable { public static PowerSource from(Raw.PowerSource sc2ApiPowerSource) { require("sc2api power source", sc2ApiPowerSource); return new PowerSource(sc2ApiPowerSource); } private PowerSource(Raw.PowerSource sc2ApiPowerSource); static PowerSource from(Raw.PowerSource sc2ApiPowerSource); P... |
@Test void throwsExceptionWhenSc2ApiEffectIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> EffectLocations.from(nothing())) .withMessage("sc2api effect is required"); } | public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); static EffectLocations from(Raw.Effect sc2ApiEffect); Effect getEffect(); Set<Poi... | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); static EffectLocations from(Raw.Effect sc2ApiEffect); Effect getEffect(); Set<Poi... |
@Test void convertsAllFieldsFromSc2ApiEffect() { assertThatAllFieldsAreConverted(EffectLocations.from(sc2ApiEffect())); } | public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); static EffectLocations from(Raw.Effect sc2ApiEffect); Effect getEffect(); Set<Poi... | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); static EffectLocations from(Raw.Effect sc2ApiEffect); Effect getEffect(); Set<Poi... |
@Test void throwsExceptionWhenEffectIdIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> EffectLocations.from(without( () -> sc2ApiEffect().toBuilder(), Raw.Effect.Builder::clearEffectId).build())) .withMessage("effect is required"); } | public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); } | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); static EffectLocations from(Raw.Effect sc2ApiEffect); Effect getEffect(); Set<Poi... | EffectLocations implements Serializable { public static EffectLocations from(Raw.Effect sc2ApiEffect) { require("sc2api effect", sc2ApiEffect); return new EffectLocations(sc2ApiEffect); } private EffectLocations(Raw.Effect sc2ApiEffect); static EffectLocations from(Raw.Effect sc2ApiEffect); Effect getEffect(); Set<Poi... |
@Test void throwsExceptionWhenSc2ApiEventIsNull() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> Event.from(nothing())) .withMessage("sc2api event is required"); } | public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } } | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } private Event(Raw.Event sc2ApiEvent); } | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } private Event(Raw.Event sc2ApiEvent); static Event from(Raw.Event sc2ApiEvent); Set<Tag> getDeadUnits(); @Override boolean equals(Object o); @Override int hashCode();... | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } private Event(Raw.Event sc2ApiEvent); static Event from(Raw.Event sc2ApiEvent); Set<Tag> getDeadUnits(); @Override boolean equals(Object o); @Override int hashCode();... |
@Test void convertsAllFieldsFromSc2ApiEvent() { assertThatAllFieldsAreConverted(Event.from(sc2ApiEvent())); } | public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } } | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } private Event(Raw.Event sc2ApiEvent); } | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } private Event(Raw.Event sc2ApiEvent); static Event from(Raw.Event sc2ApiEvent); Set<Tag> getDeadUnits(); @Override boolean equals(Object o); @Override int hashCode();... | Event implements Serializable { public static Event from(Raw.Event sc2ApiEvent) { require("sc2api event", sc2ApiEvent); return new Event(sc2ApiEvent); } private Event(Raw.Event sc2ApiEvent); static Event from(Raw.Event sc2ApiEvent); Set<Tag> getDeadUnits(); @Override boolean equals(Object o); @Override int hashCode();... |
@Test void throwsExceptionWhenNameIsNotProvided() { assertThatExceptionOfType(IllegalArgumentException.class) .isThrownBy(() -> UnitTypeData.from(without( () -> sc2ApiUnitTypeData().toBuilder(), Data.UnitTypeData.Builder::clearName).build())) .withMessage("name is required"); } | public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); } | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... | UnitTypeData implements Serializable { public static UnitTypeData from(Data.UnitTypeData sc2ApiUnitTypeData) { require("sc2api unit type data", sc2ApiUnitTypeData); return new UnitTypeData(sc2ApiUnitTypeData); } private UnitTypeData(Data.UnitTypeData sc2ApiUnitTypeData); static UnitTypeData from(Data.UnitTypeData sc2A... |
@Test void throwsExceptionWhenExecutablePathDoesNotExist() { asWindows(); userHome.newFile(WIN_USER_DIR.resolve("Starcraft II"), EXECUTE_INFO_TXT); assertThatExceptionOfType(StarCraft2ControllerException.class) .isThrownBy(() -> starcraft2Game().getGameConfiguration()) .withMessage("Invalid argument was provided") .wit... | public static Builder starcraft2Game() { return new Builder(); } | S2Controller extends DefaultSubscriber<Response> { public static Builder starcraft2Game() { return new Builder(); } } | S2Controller extends DefaultSubscriber<Response> { public static Builder starcraft2Game() { return new Builder(); } private S2Controller(Config config); } | S2Controller extends DefaultSubscriber<Response> { public static Builder starcraft2Game() { return new Builder(); } private S2Controller(Config config); static Builder starcraft2Game(); S2Controller untilReady(); void stop(); boolean stopAndWait(); boolean stopAndWait(long timeoutInMillis); void isInState(GameStatus e... | S2Controller extends DefaultSubscriber<Response> { public static Builder starcraft2Game() { return new Builder(); } private S2Controller(Config config); static Builder starcraft2Game(); S2Controller untilReady(); void stop(); boolean stopAndWait(); boolean stopAndWait(long timeoutInMillis); void isInState(GameStatus e... |
@Test void returnsEmptyArrayForNullInput() { assertThat(new RequestSerializer().apply(nothing())).as("serialized request").isEqualTo(EMPTY_ARRAY); } | @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutputStream(sc2ApiRequest.getSerializedSize()); try { sc2Api... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... |
@Test void serializesSc2ApiRequestToBytes() throws Exception { RequestPing ping = ping(); Sc2Api.Request initialRequest = Sc2Api.Request.newBuilder() .setPing(Sc2Api.RequestPing.newBuilder().build()) .setId(ping.getId()) .build(); byte[] serializedRequest = new RequestSerializer().apply(ping); assertThat(serializedRequ... | @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutputStream(sc2ApiRequest.getSerializedSize()); try { sc2Api... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... | RequestSerializer implements Function<Request, byte[]> { @Override public byte[] apply(Request request) { if (!isSet(request)) return new byte[0]; Sc2Api.Request sc2ApiRequest = request.toSc2Api(); sc2ApiRequest = sc2ApiRequest.toBuilder().setId(request.getId()).build(); ByteArrayOutputStream output = new ByteArrayOutp... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.