#5076

Committed 07 Oct 2025 12:35PM UTC coverage: 37.132% (+0.007%) from 37.125%

Build # #5076

Build Type

push

github

Committed by

web-flow

Commit Message

test: Change `Event.additionalDetails` field assertion in events test (box/box-codegen#858) (#1491)

Run Details

18454 of 49699 relevant lines covered (37.13%)

0.37 hits per line

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

20.0

/src/main/java/com/box/sdkgen/schemas/signtemplate/SignTemplateAdditionalInfoField.java

package com.box.sdkgen.schemas.signtemplate;

import com.box.sdkgen.internal.NullableFieldTracker;
import com.box.sdkgen.internal.SerializableObject;
import com.box.sdkgen.serialization.json.EnumWrapper;
import com.box.sdkgen.serialization.json.Valuable;
import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

@JsonFilter("nullablePropertyFilter")
public class SignTemplateAdditionalInfoField extends SerializableObject {

  /** Non editable fields. */
  @JsonDeserialize(using = NonEditableDeserializer.class)
  @JsonSerialize(using = NonEditableSerializer.class)
  @JsonProperty("non_editable")
  protected List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> nonEditable;

  /** Required fields. */
  protected SignTemplateAdditionalInfoRequiredField required;

  public SignTemplateAdditionalInfoField() {
    super();
  }

  protected SignTemplateAdditionalInfoField(Builder builder) {
    super();
    this.nonEditable = builder.nonEditable;
    this.required = builder.required;
    markNullableFieldsAsSet(builder.getExplicitlySetNullableFields());
  }

  public List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> getNonEditable() {
    return nonEditable;
  }

  public SignTemplateAdditionalInfoRequiredField getRequired() {
    return required;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    SignTemplateAdditionalInfoField casted = (SignTemplateAdditionalInfoField) o;
    return Objects.equals(nonEditable, casted.nonEditable)
        && Objects.equals(required, casted.required);
  }

  @Override
  public int hashCode() {
    return Objects.hash(nonEditable, required);
  }

  @Override
  public String toString() {
    return "SignTemplateAdditionalInfoField{"
        + "nonEditable='"
        + nonEditable
        + '\''
        + ", "
        + "required='"
        + required
        + '\''
        + "}";
  }

  public static class Builder extends NullableFieldTracker {

    protected List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> nonEditable;

    protected SignTemplateAdditionalInfoRequiredField required;

    public Builder nonEditable(List<? extends Valuable> nonEditable) {
      this.nonEditable =
          EnumWrapper.wrapValuableEnumList(
              nonEditable, SignTemplateAdditionalInfoNonEditableField.class);
      return this;
    }

    public Builder required(SignTemplateAdditionalInfoRequiredField required) {
      this.required = required;
      return this;
    }

    public SignTemplateAdditionalInfoField build() {
      return new SignTemplateAdditionalInfoField(this);
    }
  }

  public static class NonEditableDeserializer
      extends JsonDeserializer<List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>> {

    public final JsonDeserializer<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>
        elementDeserializer;

    public NonEditableDeserializer() {
      super();
      this.elementDeserializer =
          new SignTemplateAdditionalInfoNonEditableField
              .SignTemplateAdditionalInfoNonEditableFieldDeserializer();
    }

    @Override
    public List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> deserialize(
        JsonParser p, DeserializationContext ctxt) throws IOException {
      JsonNode node = p.getCodec().readTree(p);
      List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> elements = new ArrayList<>();
      for (JsonNode item : node) {
        JsonParser pa = item.traverse(p.getCodec());
        pa.nextToken();
        elements.add(elementDeserializer.deserialize(pa, ctxt));
      }
      return elements;
    }
  }

  public static class NonEditableSerializer
      extends JsonSerializer<List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>> {

    public final JsonSerializer<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>
        elementSerializer;

    public NonEditableSerializer() {
      super();
      this.elementSerializer =
          new SignTemplateAdditionalInfoNonEditableField
              .SignTemplateAdditionalInfoNonEditableFieldSerializer();
    }

    @Override
    public void serialize(
        List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> value,
        JsonGenerator gen,
        SerializerProvider serializers)
        throws IOException {
      gen.writeStartArray();
      for (EnumWrapper<SignTemplateAdditionalInfoNonEditableField> item : value) {
        elementSerializer.serialize(item, gen, serializers);
      }
      gen.writeEndArray();
    }
  }
}

1	package com.box.sdkgen.schemas.signtemplate;
2
3	import com.box.sdkgen.internal.NullableFieldTracker;
4	import com.box.sdkgen.internal.SerializableObject;
5	import com.box.sdkgen.serialization.json.EnumWrapper;
6	import com.box.sdkgen.serialization.json.Valuable;
7	import com.fasterxml.jackson.annotation.JsonFilter;
8	import com.fasterxml.jackson.annotation.JsonProperty;
9	import com.fasterxml.jackson.core.JsonGenerator;
10	import com.fasterxml.jackson.core.JsonParser;
11	import com.fasterxml.jackson.databind.DeserializationContext;
12	import com.fasterxml.jackson.databind.JsonDeserializer;
13	import com.fasterxml.jackson.databind.JsonNode;
14	import com.fasterxml.jackson.databind.JsonSerializer;
15	import com.fasterxml.jackson.databind.SerializerProvider;
16	import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
17	import com.fasterxml.jackson.databind.annotation.JsonSerialize;
18	import java.io.IOException;
19	import java.util.ArrayList;
20	import java.util.List;
21	import java.util.Objects;
22
23	@JsonFilter("nullablePropertyFilter")
24	public class SignTemplateAdditionalInfoField extends SerializableObject {
25
26	/** Non editable fields. */
27	@JsonDeserialize(using = NonEditableDeserializer.class)
28	@JsonSerialize(using = NonEditableSerializer.class)
29	@JsonProperty("non_editable")
30	protected List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> nonEditable;
31
32	/** Required fields. */
33	protected SignTemplateAdditionalInfoRequiredField required;
34
35	public SignTemplateAdditionalInfoField() {
36	super();	1✔
37	}	1✔
38
39	protected SignTemplateAdditionalInfoField(Builder builder) {
40	super();	×
41	this.nonEditable = builder.nonEditable;	×
42	this.required = builder.required;	×
43	markNullableFieldsAsSet(builder.getExplicitlySetNullableFields());	×
44	}	×
45
46	public List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> getNonEditable() {
47	return nonEditable;	×
48	}
49
50	public SignTemplateAdditionalInfoRequiredField getRequired() {
51	return required;	×
52	}
53
54	@Override
55	public boolean equals(Object o) {
56	if (this == o) {	×
57	return true;	×
58	}
59	if (o == null \|\| getClass() != o.getClass()) {	×
60	return false;	×
61	}
62	SignTemplateAdditionalInfoField casted = (SignTemplateAdditionalInfoField) o;	×
63	return Objects.equals(nonEditable, casted.nonEditable)	×
64	&& Objects.equals(required, casted.required);	×
65	}
66
67	@Override
68	public int hashCode() {
69	return Objects.hash(nonEditable, required);	×
70	}
71
72	@Override
73	public String toString() {
74	return "SignTemplateAdditionalInfoField{"	×
75	+ "nonEditable='"
76	+ nonEditable
77	+ '\''
78	+ ", "
79	+ "required='"
80	+ required
81	+ '\''
82	+ "}";
83	}
84
85	public static class Builder extends NullableFieldTracker {	×
86
87	protected List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> nonEditable;
88
89	protected SignTemplateAdditionalInfoRequiredField required;
90
91	public Builder nonEditable(List<? extends Valuable> nonEditable) {
92	this.nonEditable =	×
93	EnumWrapper.wrapValuableEnumList(	×
94	nonEditable, SignTemplateAdditionalInfoNonEditableField.class);
95	return this;	×
96	}
97
98	public Builder required(SignTemplateAdditionalInfoRequiredField required) {
99	this.required = required;	×
100	return this;	×
101	}
102
103	public SignTemplateAdditionalInfoField build() {
104	return new SignTemplateAdditionalInfoField(this);	×
105	}
106	}
107
108	public static class NonEditableDeserializer
109	extends JsonDeserializer<List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>> {
110
111	public final JsonDeserializer<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>
112	elementDeserializer;
113
114	public NonEditableDeserializer() {
115	super();	1✔
116	this.elementDeserializer =	1✔
117	new SignTemplateAdditionalInfoNonEditableField
118	.SignTemplateAdditionalInfoNonEditableFieldDeserializer();
119	}	1✔
120
121	@Override
122	public List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> deserialize(
123	JsonParser p, DeserializationContext ctxt) throws IOException {
124	JsonNode node = p.getCodec().readTree(p);	1✔
125	List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> elements = new ArrayList<>();	1✔
126	for (JsonNode item : node) {	1✔
127	JsonParser pa = item.traverse(p.getCodec());	×
128	pa.nextToken();	×
129	elements.add(elementDeserializer.deserialize(pa, ctxt));	×
130	}	×
131	return elements;	1✔
132	}
133	}
134
135	public static class NonEditableSerializer
136	extends JsonSerializer<List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>> {
137
138	public final JsonSerializer<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>>
139	elementSerializer;
140
141	public NonEditableSerializer() {
142	super();	×
143	this.elementSerializer =	×
144	new SignTemplateAdditionalInfoNonEditableField
145	.SignTemplateAdditionalInfoNonEditableFieldSerializer();
146	}	×
147
148	@Override
149	public void serialize(
150	List<EnumWrapper<SignTemplateAdditionalInfoNonEditableField>> value,
151	JsonGenerator gen,
152	SerializerProvider serializers)
153	throws IOException {
154	gen.writeStartArray();	×
155	for (EnumWrapper<SignTemplateAdditionalInfoNonEditableField> item : value) {	×
156	elementSerializer.serialize(item, gen, serializers);	×
157	}	×
158	gen.writeEndArray();	×
159	}	×
160	}
161	}

box / box-java-sdk / #5076

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