#4742

Committed 06 Aug 2025 12:44PM UTC coverage: 38.272% (-0.08%) from 38.352%

Build # #4742

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Adjust `github` workflows for legacy repos (box/box-codegen#772) (#1331)

Run Details

19031 of 49725 relevant lines covered (38.27%)

0.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

46.34

/src/main/java/com/box/sdkgen/serialization/json/EnumWrapper.java

package com.box.sdkgen.serialization.json;

import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

public class EnumWrapper<E extends Enum<E> & Valuable> implements Valuable {
  private E value;
  private final String stringValue;

  public EnumWrapper(E enumValue) {
    this.stringValue = enumValue.getValue();
    this.value = enumValue;
  }

  public EnumWrapper(String value) {
    this.stringValue = value;
  }

  public E getEnumValue() {
    return value;
  }

  public String getStringValue() {
    return stringValue;
  }

  @Override
  public String getValue() {
    return stringValue;
  }

  @Override
  public String toString() {
    return "EnumWrapper{" + "value=" + value + ", stringValue='" + stringValue + '\'' + '}';
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    EnumWrapper<?> casted = (EnumWrapper<?>) o;
    return Objects.equals(stringValue, casted.stringValue);
  }

  @Override
  public int hashCode() {
    return Objects.hash(stringValue);
  }

  public static <T extends Enum<T> & Valuable> List<EnumWrapper<T>> wrapValuableEnumList(
      List<? extends Valuable> listField, Class<T> enumType) {
    if (listField == null || listField.isEmpty()) {
      return Collections.emptyList();
    }
    return listField.stream()
        .map(
            field -> {
              if (field instanceof EnumWrapper) {
                return (EnumWrapper<T>) field;
              } else if (field.getClass().isAssignableFrom(enumType)) {
                return new EnumWrapper<>(enumType.cast(field));
              } else {
                throw new IllegalArgumentException("Unsupported type: " + field.getClass());
              }
            })
        .collect(Collectors.toList());
  }

  public static <T extends Enum<T> & Valuable>
      List<List<EnumWrapper<T>>> wrapValuableEnumListOfLists(
          List<List<? extends Valuable>> listOfLists, Class<T> enumType) {
    if (listOfLists == null || listOfLists.isEmpty()) {
      return Collections.emptyList();
    }
    return listOfLists.stream()
        .map(list -> wrapValuableEnumList(list, enumType))
        .collect(Collectors.toList());
  }

  public static <T extends Enum<T> & Valuable> List<EnumWrapper<T>> wrapListOfEnums(List<T> enums) {
    return enums.stream().map(EnumWrapper::new).collect(Collectors.toList());
  }

  public static <T extends Enum<T> & Valuable> List<List<EnumWrapper<T>>> wrapListOfListsOfEnums(
      List<List<T>> listOfEnums) {
    return listOfEnums.stream().map(EnumWrapper::wrapListOfEnums).collect(Collectors.toList());
  }

  public static <T extends Enum<T> & Valuable> String convertToString(EnumWrapper<T> enumValue) {
    if (enumValue == null) {
      return null;
    }
    return enumValue.getStringValue();
  }

  public static <T extends Enum<T> & Valuable> List<String> convertToString(
      List<EnumWrapper<T>> enumValue) {
    if (enumValue == null) {
      return null;
    }
    return enumValue.stream().map(EnumWrapper::getStringValue).collect(Collectors.toList());
  }
}

1	package com.box.sdkgen.serialization.json;
2
3	import java.util.Collections;
4	import java.util.List;
5	import java.util.Objects;
6	import java.util.stream.Collectors;
7
8	public class EnumWrapper<E extends Enum<E> & Valuable> implements Valuable {
9	private E value;
10	private final String stringValue;
11
12	public EnumWrapper(E enumValue) {	1✔
13	this.stringValue = enumValue.getValue();	1✔
14	this.value = enumValue;	1✔
15	}	1✔
16
17	public EnumWrapper(String value) {	1✔
18	this.stringValue = value;	1✔
19	}	1✔
20
21	public E getEnumValue() {
22	return value;	1✔
23	}
24
25	public String getStringValue() {
26	return stringValue;	1✔
27	}
28
29	@Override
30	public String getValue() {
31	return stringValue;	×
32	}
33
34	@Override
35	public String toString() {
36	return "EnumWrapper{" + "value=" + value + ", stringValue='" + stringValue + '\'' + '}';	×
37	}
38
39	@Override
40	public boolean equals(Object o) {
41	if (this == o) {	×
42	return true;	×
43	}
44	if (o == null \|\| getClass() != o.getClass()) {	×
45	return false;	×
46	}
47	EnumWrapper<?> casted = (EnumWrapper<?>) o;	×
48	return Objects.equals(stringValue, casted.stringValue);	×
49	}
50
51	@Override
52	public int hashCode() {
53	return Objects.hash(stringValue);	×
54	}
55
56	public static <T extends Enum<T> & Valuable> List<EnumWrapper<T>> wrapValuableEnumList(
57	List<? extends Valuable> listField, Class<T> enumType) {
58	if (listField == null \|\| listField.isEmpty()) {	1✔
59	return Collections.emptyList();	×
60	}
61	return listField.stream()	1✔
62	.map(	1✔
63	field -> {
64	if (field instanceof EnumWrapper) {	1✔
65	return (EnumWrapper<T>) field;	×
66	} else if (field.getClass().isAssignableFrom(enumType)) {	1✔
67	return new EnumWrapper<>(enumType.cast(field));	1✔
68	} else {
69	throw new IllegalArgumentException("Unsupported type: " + field.getClass());	×
70	}
71	})
72	.collect(Collectors.toList());	1✔
73	}
74
75	public static <T extends Enum<T> & Valuable>
76	List<List<EnumWrapper<T>>> wrapValuableEnumListOfLists(
77	List<List<? extends Valuable>> listOfLists, Class<T> enumType) {
78	if (listOfLists == null \|\| listOfLists.isEmpty()) {	×
79	return Collections.emptyList();	×
80	}
81	return listOfLists.stream()	×
82	.map(list -> wrapValuableEnumList(list, enumType))	×
83	.collect(Collectors.toList());	×
84	}
85
86	public static <T extends Enum<T> & Valuable> List<EnumWrapper<T>> wrapListOfEnums(List<T> enums) {
87	return enums.stream().map(EnumWrapper::new).collect(Collectors.toList());	×
88	}
89
90	public static <T extends Enum<T> & Valuable> List<List<EnumWrapper<T>>> wrapListOfListsOfEnums(
91	List<List<T>> listOfEnums) {
92	return listOfEnums.stream().map(EnumWrapper::wrapListOfEnums).collect(Collectors.toList());	×
93	}
94
95	public static <T extends Enum<T> & Valuable> String convertToString(EnumWrapper<T> enumValue) {
96	if (enumValue == null) {	1✔
97	return null;	1✔
98	}
99	return enumValue.getStringValue();	1✔
100	}
101
102	public static <T extends Enum<T> & Valuable> List<String> convertToString(
103	List<EnumWrapper<T>> enumValue) {
104	if (enumValue == null) {	×
105	return null;	×
106	}
107	return enumValue.stream().map(EnumWrapper::getStringValue).collect(Collectors.toList());	×
108	}
109	}

box / box-java-sdk / #4742

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous