diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java index 423c905..95ec8bc 100644 --- a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/GppModel.java @@ -16,6 +16,9 @@ import com.iab.gpp.encoder.section.UsDe; import com.iab.gpp.encoder.section.UsFl; import com.iab.gpp.encoder.section.UsIa; +import com.iab.gpp.encoder.section.UsIn; +import com.iab.gpp.encoder.section.UsKy; +import com.iab.gpp.encoder.section.UsMd; import com.iab.gpp.encoder.section.UsMn; import com.iab.gpp.encoder.section.UsMt; import com.iab.gpp.encoder.section.UsNat; @@ -23,6 +26,7 @@ import com.iab.gpp.encoder.section.UsNh; import com.iab.gpp.encoder.section.UsNj; import com.iab.gpp.encoder.section.UsOr; +import com.iab.gpp.encoder.section.UsRi; import com.iab.gpp.encoder.section.UsTn; import com.iab.gpp.encoder.section.UsTx; import com.iab.gpp.encoder.section.UsUt; @@ -66,6 +70,10 @@ public class GppModel extends AbstractEncodable { constructors.add(UsNj::new); constructors.add(UsTn::new); constructors.add(UsMn::new); + constructors.add(UsIn::new); + constructors.add(UsMd::new); + constructors.add(UsKy::new); + constructors.add(UsRi::new); for (Supplier> constructor : constructors) { EncodableSection prototype = constructor.get(); @@ -265,6 +273,22 @@ public UsMn getUsMnSection() { return (UsMn) getSection(UsMn.ID); } + public UsIn getUsInSection() { + return (UsIn) getSection(UsIn.ID); + } + + public UsKy getUsKySection() { + return (UsKy) getSection(UsKy.ID); + } + + public UsMd getUsMdSection() { + return (UsMd) getSection(UsMd.ID); + } + + public UsRi getUsRiSection() { + return (UsRi) getSection(UsRi.ID); + } + public IntegerSet getSectionIds() { ensureDecode(); return header.getSectionsIds(); diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsInField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsInField.java new file mode 100644 index 0000000..fcf1056 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsInField.java @@ -0,0 +1,62 @@ +package com.iab.gpp.encoder.field; + +import com.iab.gpp.encoder.datatype.DataType; +import com.iab.gpp.encoder.datatype.EncodableFibonacciIntegerRange; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.section.UsIn; + +public enum UsInField implements FieldKey { + SECTION_ID(new EncodableFixedInteger<>("SectionID", 6, UsIn.ID)), + VERSION(new EncodableFixedInteger<>("Version", 6, UsIn.VERSION)), + SUB_SECTIONS(new EncodableFibonacciIntegerRange<>("SubSections")), + + MSPA_VERSION(new EncodableFixedInteger<>("MspaVersion", 6, 0)), + MSPA_COVERED_TRANSACTION( + new EncodableFixedInteger<>("MspaCoveredTransaction", 2, 1, VALIDATOR_12)), + MSPA_MODE(new EncodableFixedInteger<>("MspaMode", 2, 0, VALIDATOR_012)), + PROCESSING_NOTICE(new EncodableFixedInteger<>("ProcessingNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT_NOTICE(new EncodableFixedInteger<>("SaleOptOutNotice", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT_NOTICE( + new EncodableFixedInteger<>("TargetedAdvertisingOptOutNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT(new EncodableFixedInteger<>("SaleOptOut", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT( + new EncodableFixedInteger<>("TargetedAdvertisingOptOut", 2, 0, VALIDATOR_012)), + KNOWN_CHILD_SENSITIVE_DATA_CONSENTS( + new EncodableFixedInteger<>("KnownChildSensitiveDataConsents", 2, 0, VALIDATOR_012)), + ADDITIONAL_DATA_PROCESSING_CONSENT( + new EncodableFixedInteger<>("AdditionalDataProcessingConsent", 2, 0, VALIDATOR_012)), + + SENSITIVE_DATA_PROCESSING( + new EncodableFixedIntegerList<>("SensitiveDataProcessing", 2, 8, VALIDATOR_LIST_012)); + + private final DataType type; + + UsInField(DataType type) { + this.type = type; + } + + @Override + public DataType getType() { + return type; + } + + public static final FieldNames USIN_HEADER_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsInField.SECTION_ID, UsInField.VERSION, UsInField.SUB_SECTIONS); + + public static final FieldNames USIN_CORE_SEGMENT_FIELD_NAMES = + new FieldNames<>( + UsInField.MSPA_VERSION, + UsInField.MSPA_COVERED_TRANSACTION, + UsInField.MSPA_MODE, + UsInField.PROCESSING_NOTICE, + UsInField.SALE_OPT_OUT_NOTICE, + UsInField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsInField.SALE_OPT_OUT, + UsInField.TARGETED_ADVERTISING_OPT_OUT, + UsInField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsInField.ADDITIONAL_DATA_PROCESSING_CONSENT); + + public static final FieldNames USIN_SENSITIVE_DATA_CONSENTS_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsInField.SENSITIVE_DATA_PROCESSING); +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsKyField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsKyField.java new file mode 100644 index 0000000..c05faf7 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsKyField.java @@ -0,0 +1,62 @@ +package com.iab.gpp.encoder.field; + +import com.iab.gpp.encoder.datatype.DataType; +import com.iab.gpp.encoder.datatype.EncodableFibonacciIntegerRange; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.section.UsKy; + +public enum UsKyField implements FieldKey { + SECTION_ID(new EncodableFixedInteger<>("SectionID", 6, UsKy.ID)), + VERSION(new EncodableFixedInteger<>("Version", 6, UsKy.VERSION)), + SUB_SECTIONS(new EncodableFibonacciIntegerRange<>("SubSections")), + + MSPA_VERSION(new EncodableFixedInteger<>("MspaVersion", 6, 0)), + MSPA_COVERED_TRANSACTION( + new EncodableFixedInteger<>("MspaCoveredTransaction", 2, 1, VALIDATOR_12)), + MSPA_MODE(new EncodableFixedInteger<>("MspaMode", 2, 0, VALIDATOR_012)), + PROCESSING_NOTICE(new EncodableFixedInteger<>("ProcessingNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT_NOTICE(new EncodableFixedInteger<>("SaleOptOutNotice", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT_NOTICE( + new EncodableFixedInteger<>("TargetedAdvertisingOptOutNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT(new EncodableFixedInteger<>("SaleOptOut", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT( + new EncodableFixedInteger<>("TargetedAdvertisingOptOut", 2, 0, VALIDATOR_012)), + KNOWN_CHILD_SENSITIVE_DATA_CONSENTS( + new EncodableFixedInteger<>("KnownChildSensitiveDataConsents", 2, 0, VALIDATOR_012)), + ADDITIONAL_DATA_PROCESSING_CONSENT( + new EncodableFixedInteger<>("AdditionalDataProcessingConsent", 2, 0, VALIDATOR_012)), + + SENSITIVE_DATA_PROCESSING( + new EncodableFixedIntegerList<>("SensitiveDataProcessing", 2, 8, VALIDATOR_LIST_012)); + + private final DataType type; + + UsKyField(DataType type) { + this.type = type; + } + + @Override + public DataType getType() { + return type; + } + + public static final FieldNames USKY_HEADER_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsKyField.SECTION_ID, UsKyField.VERSION, UsKyField.SUB_SECTIONS); + + public static final FieldNames USKY_CORE_SEGMENT_FIELD_NAMES = + new FieldNames<>( + UsKyField.MSPA_VERSION, + UsKyField.MSPA_COVERED_TRANSACTION, + UsKyField.MSPA_MODE, + UsKyField.PROCESSING_NOTICE, + UsKyField.SALE_OPT_OUT_NOTICE, + UsKyField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsKyField.SALE_OPT_OUT, + UsKyField.TARGETED_ADVERTISING_OPT_OUT, + UsKyField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsKyField.ADDITIONAL_DATA_PROCESSING_CONSENT); + + public static final FieldNames USKY_SENSITIVE_DATA_CONSENTS_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsKyField.SENSITIVE_DATA_PROCESSING); +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsMdField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsMdField.java new file mode 100644 index 0000000..58bf0a9 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsMdField.java @@ -0,0 +1,59 @@ +package com.iab.gpp.encoder.field; + +import com.iab.gpp.encoder.datatype.DataType; +import com.iab.gpp.encoder.datatype.EncodableBoolean; +import com.iab.gpp.encoder.datatype.EncodableFibonacciIntegerRange; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.section.UsMd; + +public enum UsMdField implements FieldKey { + SECTION_ID(new EncodableFixedInteger<>("SectionID", 6, UsMd.ID)), + VERSION(new EncodableFixedInteger<>("Version", 6, UsMd.VERSION)), + SUB_SECTIONS(new EncodableFibonacciIntegerRange<>("SubSections")), + + MSPA_VERSION(new EncodableFixedInteger<>("MspaVersion", 6, 0)), + MSPA_COVERED_TRANSACTION( + new EncodableFixedInteger<>("MspaCoveredTransaction", 2, 1, VALIDATOR_12)), + MSPA_MODE(new EncodableFixedInteger<>("MspaMode", 2, 0, VALIDATOR_012)), + PROCESSING_NOTICE(new EncodableFixedInteger<>("ProcessingNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT_NOTICE(new EncodableFixedInteger<>("SaleOptOutNotice", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT_NOTICE( + new EncodableFixedInteger<>("TargetedAdvertisingOptOutNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT(new EncodableFixedInteger<>("SaleOptOut", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT( + new EncodableFixedInteger<>("TargetedAdvertisingOptOut", 2, 0, VALIDATOR_012)), + ADDITIONAL_DATA_PROCESSING_CONSENT( + new EncodableFixedInteger<>("AdditionalDataProcessingConsent", 2, 0, VALIDATOR_012)), + + GPC_SUBSECTION_TYPE(new EncodableFixedInteger<>("GpcSubSectionType", 2, 1)), + GPC(new EncodableBoolean<>("Gpc", false)); + + private final DataType type; + + UsMdField(DataType type) { + this.type = type; + } + + @Override + public DataType getType() { + return type; + } + + public static final FieldNames USMD_HEADER_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsMdField.SECTION_ID, UsMdField.VERSION, UsMdField.SUB_SECTIONS); + + public static final FieldNames USMD_CORE_SEGMENT_FIELD_NAMES = + new FieldNames<>( + UsMdField.MSPA_VERSION, + UsMdField.MSPA_COVERED_TRANSACTION, + UsMdField.MSPA_MODE, + UsMdField.PROCESSING_NOTICE, + UsMdField.SALE_OPT_OUT_NOTICE, + UsMdField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsMdField.SALE_OPT_OUT, + UsMdField.TARGETED_ADVERTISING_OPT_OUT, + UsMdField.ADDITIONAL_DATA_PROCESSING_CONSENT); + + public static final FieldNames USMD_GPC_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsMdField.GPC_SUBSECTION_TYPE, UsMdField.GPC); +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsRiField.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsRiField.java new file mode 100644 index 0000000..d5e5917 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/field/UsRiField.java @@ -0,0 +1,62 @@ +package com.iab.gpp.encoder.field; + +import com.iab.gpp.encoder.datatype.DataType; +import com.iab.gpp.encoder.datatype.EncodableFibonacciIntegerRange; +import com.iab.gpp.encoder.datatype.EncodableFixedInteger; +import com.iab.gpp.encoder.datatype.EncodableFixedIntegerList; +import com.iab.gpp.encoder.section.UsRi; + +public enum UsRiField implements FieldKey { + SECTION_ID(new EncodableFixedInteger<>("SectionID", 6, UsRi.ID)), + VERSION(new EncodableFixedInteger<>("Version", 6, UsRi.VERSION)), + SUB_SECTIONS(new EncodableFibonacciIntegerRange<>("SubSections")), + + MSPA_VERSION(new EncodableFixedInteger<>("MspaVersion", 6, 0)), + MSPA_COVERED_TRANSACTION( + new EncodableFixedInteger<>("MspaCoveredTransaction", 2, 1, VALIDATOR_12)), + MSPA_MODE(new EncodableFixedInteger<>("MspaMode", 2, 0, VALIDATOR_012)), + PROCESSING_NOTICE(new EncodableFixedInteger<>("ProcessingNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT_NOTICE(new EncodableFixedInteger<>("SaleOptOutNotice", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT_NOTICE( + new EncodableFixedInteger<>("TargetedAdvertisingOptOutNotice", 2, 0, VALIDATOR_012)), + SALE_OPT_OUT(new EncodableFixedInteger<>("SaleOptOut", 2, 0, VALIDATOR_012)), + TARGETED_ADVERTISING_OPT_OUT( + new EncodableFixedInteger<>("TargetedAdvertisingOptOut", 2, 0, VALIDATOR_012)), + KNOWN_CHILD_SENSITIVE_DATA_CONSENTS( + new EncodableFixedInteger<>("KnownChildSensitiveDataConsents", 2, 0, VALIDATOR_012)), + ADDITIONAL_DATA_PROCESSING_CONSENT( + new EncodableFixedInteger<>("AdditionalDataProcessingConsent", 2, 0, VALIDATOR_012)), + + SENSITIVE_DATA_PROCESSING( + new EncodableFixedIntegerList<>("SensitiveDataProcessing", 2, 8, VALIDATOR_LIST_012)); + + private final DataType type; + + UsRiField(DataType type) { + this.type = type; + } + + @Override + public DataType getType() { + return type; + } + + public static final FieldNames USRI_HEADER_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsRiField.SECTION_ID, UsRiField.VERSION, UsRiField.SUB_SECTIONS); + + public static final FieldNames USRI_CORE_SEGMENT_FIELD_NAMES = + new FieldNames<>( + UsRiField.MSPA_VERSION, + UsRiField.MSPA_COVERED_TRANSACTION, + UsRiField.MSPA_MODE, + UsRiField.PROCESSING_NOTICE, + UsRiField.SALE_OPT_OUT_NOTICE, + UsRiField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, + UsRiField.SALE_OPT_OUT, + UsRiField.TARGETED_ADVERTISING_OPT_OUT, + UsRiField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, + UsRiField.ADDITIONAL_DATA_PROCESSING_CONSENT); + + public static final FieldNames USRI_SENSITIVE_DATA_CONSENTS_SEGMENT_FIELD_NAMES = + new FieldNames<>(UsRiField.SENSITIVE_DATA_PROCESSING); +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/AbstractUsSectionWithHeader.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/AbstractUsSectionWithHeader.java new file mode 100644 index 0000000..00b4cb1 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/AbstractUsSectionWithHeader.java @@ -0,0 +1,57 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.datatype.IntegerSet; +import com.iab.gpp.encoder.field.FieldKey; +import com.iab.gpp.encoder.segment.EncodableSegment; +import java.util.ArrayList; +import java.util.List; +import java.util.PrimitiveIterator; + +public abstract class AbstractUsSectionWithHeader & FieldKey> + extends AbstractUsSection { + + @SafeVarargs + protected AbstractUsSectionWithHeader(EncodableSegment... segments) { + super(segments); + } + + protected abstract E getSubSectionsKey(); + + public IntegerSet getSubSections() { + return (IntegerSet) getSegment(0).getFieldValue(getSubSectionsKey()); + } + + @Override + protected final void doDecode(CharSequence encodedString) { + List encodedSegments = SlicedCharSequence.split(encodedString, '.'); + getSegment(0).decode(encodedSegments.get(0)); + IntegerSet subSections = getSubSections(); + subSections.addInt(0); + PrimitiveIterator.OfInt it = subSections.iterator(); + while (it.hasNext()) { + int subSectionIndex = 1 + it.nextInt(); + getSegment(subSectionIndex).decode(encodedSegments.get(subSectionIndex)); + } + } + + @Override + protected final CharSequence doEncode() { + int size = size(); + List encodedSegments = new ArrayList<>(size); + IntegerSet subSections = getSubSections(); + for (int i = 2; i < size(); i++) { + EncodableSegment segment = getSegment(i); + if (segment.shouldEncode()) { + subSections.add(i - 1); + } + } + encodedSegments.add(getSegment(0).encodeCharSequence()); + encodedSegments.add(getSegment(1).encodeCharSequence()); + PrimitiveIterator.OfInt it = subSections.iterator(); + while (it.hasNext()) { + int subSectionIndex = 1 + it.nextInt(); + encodedSegments.add(getSegment(subSectionIndex).encodeCharSequence()); + } + return SlicedCharSequence.join('.', encodedSegments); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsIn.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsIn.java new file mode 100644 index 0000000..0f17592 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsIn.java @@ -0,0 +1,88 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.datatype.FixedIntegerList; +import com.iab.gpp.encoder.field.UsInField; +import com.iab.gpp.encoder.segment.Base64Segment; + +public class UsIn extends AbstractUsSectionWithHeader { + + public static final int ID = 25; + public static final int VERSION = 1; + public static final String NAME = "usin"; + + public UsIn() { + super( + new Base64Segment<>(UsInField.USIN_HEADER_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsInField.USIN_CORE_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsInField.USIN_SENSITIVE_DATA_CONSENTS_SEGMENT_FIELD_NAMES, true)); + } + + public UsIn(String encodedString) { + this(); + decode(encodedString); + } + + @Override + public int getId() { + return UsIn.ID; + } + + @Override + public String getName() { + return UsIn.NAME; + } + + @Override + public int getVersion() { + return (Integer) this.getFieldValue(UsInField.VERSION); + } + + @Override + protected final UsInField getSubSectionsKey() { + return UsInField.SUB_SECTIONS; + } + + public Integer getMspaVersion() { + return (Integer) this.getFieldValue(UsInField.MSPA_VERSION); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsInField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaMode() { + return (Integer) this.getFieldValue(UsInField.MSPA_MODE); + } + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsInField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsInField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsInField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsInField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsInField.TARGETED_ADVERTISING_OPT_OUT); + } + + public Integer getKnownChildSensitiveDataConsents() { + return (Integer) this.getFieldValue(UsInField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsInField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public FixedIntegerList getSensitiveDataProcessing() { + return (FixedIntegerList) this.getFieldValue(UsInField.SENSITIVE_DATA_PROCESSING); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsKy.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsKy.java new file mode 100644 index 0000000..bc59a0e --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsKy.java @@ -0,0 +1,88 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.datatype.FixedIntegerList; +import com.iab.gpp.encoder.field.UsKyField; +import com.iab.gpp.encoder.segment.Base64Segment; + +public class UsKy extends AbstractUsSectionWithHeader { + + public static final int ID = 26; + public static final int VERSION = 1; + public static final String NAME = "usky"; + + public UsKy() { + super( + new Base64Segment<>(UsKyField.USKY_HEADER_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsKyField.USKY_CORE_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsKyField.USKY_SENSITIVE_DATA_CONSENTS_SEGMENT_FIELD_NAMES, true)); + } + + public UsKy(String encodedString) { + this(); + decode(encodedString); + } + + @Override + public int getId() { + return UsKy.ID; + } + + @Override + public String getName() { + return UsKy.NAME; + } + + @Override + public int getVersion() { + return (Integer) this.getFieldValue(UsKyField.VERSION); + } + + @Override + protected final UsKyField getSubSectionsKey() { + return UsKyField.SUB_SECTIONS; + } + + public Integer getMspaVersion() { + return (Integer) this.getFieldValue(UsKyField.MSPA_VERSION); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsKyField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaMode() { + return (Integer) this.getFieldValue(UsKyField.MSPA_MODE); + } + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsKyField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsKyField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsKyField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsKyField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsKyField.TARGETED_ADVERTISING_OPT_OUT); + } + + public Integer getKnownChildSensitiveDataConsents() { + return (Integer) this.getFieldValue(UsKyField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsKyField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public FixedIntegerList getSensitiveDataProcessing() { + return (FixedIntegerList) this.getFieldValue(UsKyField.SENSITIVE_DATA_PROCESSING); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsMd.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsMd.java new file mode 100644 index 0000000..bfc3ab5 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsMd.java @@ -0,0 +1,83 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.field.UsMdField; +import com.iab.gpp.encoder.segment.Base64Segment; + +public class UsMd extends AbstractUsSectionWithHeader { + + public static final int ID = 24; + public static final int VERSION = 1; + public static final String NAME = "usmd"; + + public UsMd() { + super( + new Base64Segment<>(UsMdField.USMD_HEADER_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsMdField.USMD_CORE_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsMdField.USMD_GPC_SEGMENT_FIELD_NAMES, true)); + } + + public UsMd(String encodedString) { + this(); + decode(encodedString); + } + + @Override + public int getId() { + return UsMd.ID; + } + + @Override + public String getName() { + return UsMd.NAME; + } + + @Override + public int getVersion() { + return (Integer) this.getFieldValue(UsMdField.VERSION); + } + + @Override + protected final UsMdField getSubSectionsKey() { + return UsMdField.SUB_SECTIONS; + } + + public Integer getMspaVersion() { + return (Integer) this.getFieldValue(UsMdField.MSPA_VERSION); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsMdField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaMode() { + return (Integer) this.getFieldValue(UsMdField.MSPA_MODE); + } + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsMdField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsMdField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsMdField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsMdField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsMdField.TARGETED_ADVERTISING_OPT_OUT); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsMdField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public Boolean getGpc() { + return (Boolean) this.getFieldValue(UsMdField.GPC); + } +} diff --git a/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsRi.java b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsRi.java new file mode 100644 index 0000000..e0e3566 --- /dev/null +++ b/iabgpp-encoder/src/main/java/com/iab/gpp/encoder/section/UsRi.java @@ -0,0 +1,88 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.datatype.FixedIntegerList; +import com.iab.gpp.encoder.field.UsRiField; +import com.iab.gpp.encoder.segment.Base64Segment; + +public class UsRi extends AbstractUsSectionWithHeader { + + public static final int ID = 27; + public static final int VERSION = 1; + public static final String NAME = "usri"; + + public UsRi() { + super( + new Base64Segment<>(UsRiField.USRI_HEADER_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsRiField.USRI_CORE_SEGMENT_FIELD_NAMES), + new Base64Segment<>(UsRiField.USRI_SENSITIVE_DATA_CONSENTS_SEGMENT_FIELD_NAMES, true)); + } + + public UsRi(String encodedString) { + this(); + decode(encodedString); + } + + @Override + public int getId() { + return UsRi.ID; + } + + @Override + public String getName() { + return UsRi.NAME; + } + + @Override + public int getVersion() { + return (Integer) this.getFieldValue(UsRiField.VERSION); + } + + @Override + protected final UsRiField getSubSectionsKey() { + return UsRiField.SUB_SECTIONS; + } + + public Integer getMspaVersion() { + return (Integer) this.getFieldValue(UsRiField.MSPA_VERSION); + } + + public Integer getMspaCoveredTransaction() { + return (Integer) this.getFieldValue(UsRiField.MSPA_COVERED_TRANSACTION); + } + + public Integer getMspaMode() { + return (Integer) this.getFieldValue(UsRiField.MSPA_MODE); + } + + public Integer getProcessingNotice() { + return (Integer) this.getFieldValue(UsRiField.PROCESSING_NOTICE); + } + + public Integer getSaleOptOutNotice() { + return (Integer) this.getFieldValue(UsRiField.SALE_OPT_OUT_NOTICE); + } + + public Integer getTargetedAdvertisingOptOutNotice() { + return (Integer) this.getFieldValue(UsRiField.TARGETED_ADVERTISING_OPT_OUT_NOTICE); + } + + public Integer getSaleOptOut() { + return (Integer) this.getFieldValue(UsRiField.SALE_OPT_OUT); + } + + public Integer getTargetedAdvertisingOptOut() { + return (Integer) this.getFieldValue(UsRiField.TARGETED_ADVERTISING_OPT_OUT); + } + + public Integer getKnownChildSensitiveDataConsents() { + return (Integer) this.getFieldValue(UsRiField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS); + } + + public Integer getAdditionalDataProcessingConsent() { + return (Integer) this.getFieldValue(UsRiField.ADDITIONAL_DATA_PROCESSING_CONSENT); + } + + public FixedIntegerList getSensitiveDataProcessing() { + return (FixedIntegerList) this.getFieldValue(UsRiField.SENSITIVE_DATA_PROCESSING); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java index 147c340..a1bc49c 100644 --- a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/GppModelTest.java @@ -9,6 +9,9 @@ import com.iab.gpp.encoder.field.UsDeField; import com.iab.gpp.encoder.field.UsFlField; import com.iab.gpp.encoder.field.UsIaField; +import com.iab.gpp.encoder.field.UsInField; +import com.iab.gpp.encoder.field.UsKyField; +import com.iab.gpp.encoder.field.UsMdField; import com.iab.gpp.encoder.field.UsMnField; import com.iab.gpp.encoder.field.UsMtField; import com.iab.gpp.encoder.field.UsNatField; @@ -16,6 +19,7 @@ import com.iab.gpp.encoder.field.UsNhField; import com.iab.gpp.encoder.field.UsNjField; import com.iab.gpp.encoder.field.UsOrField; +import com.iab.gpp.encoder.field.UsRiField; import com.iab.gpp.encoder.field.UsTnField; import com.iab.gpp.encoder.field.UsTxField; import com.iab.gpp.encoder.field.UsUtField; @@ -29,6 +33,9 @@ import com.iab.gpp.encoder.section.UsDe; import com.iab.gpp.encoder.section.UsFl; import com.iab.gpp.encoder.section.UsIa; +import com.iab.gpp.encoder.section.UsIn; +import com.iab.gpp.encoder.section.UsKy; +import com.iab.gpp.encoder.section.UsMd; import com.iab.gpp.encoder.section.UsMn; import com.iab.gpp.encoder.section.UsMt; import com.iab.gpp.encoder.section.UsNat; @@ -36,6 +43,7 @@ import com.iab.gpp.encoder.section.UsNh; import com.iab.gpp.encoder.section.UsNj; import com.iab.gpp.encoder.section.UsOr; +import com.iab.gpp.encoder.section.UsRi; import com.iab.gpp.encoder.section.UsTn; import com.iab.gpp.encoder.section.UsTx; import com.iab.gpp.encoder.section.UsUt; @@ -127,6 +135,10 @@ public void testEncodeDefaultAll() { gppModel.setFieldValue(UsNj.NAME, UsNjField.VERSION, UsNj.VERSION); gppModel.setFieldValue(UsTn.NAME, UsTnField.VERSION, UsTn.VERSION); gppModel.setFieldValue(UsMn.NAME, UsMnField.VERSION, UsMn.VERSION); + gppModel.setFieldValue(UsIn.NAME, UsInField.VERSION, UsIn.VERSION); + gppModel.setFieldValue(UsMd.NAME, UsMdField.VERSION, UsMd.VERSION); + gppModel.setFieldValue(UsKy.NAME, UsKyField.VERSION, UsKy.VERSION); + gppModel.setFieldValue(UsRi.NAME, UsRiField.VERSION, UsRi.VERSION); Assertions.assertEquals(true, gppModel.hasSection(TcfEuV2.NAME)); Assertions.assertEquals(true, gppModel.hasSection(TcfCaV1.NAME)); @@ -148,10 +160,14 @@ public void testEncodeDefaultAll() { Assertions.assertEquals(true, gppModel.hasSection(UsNj.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsTn.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsMn.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsIn.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsMd.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsKy.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsRi.NAME)); String gppString = gppModel.encode(); Assertions.assertEquals( - "DBACOYs~CPSG_8APSG_8AAAAAAENAAFgAAAAAAAAAAAAAAAAAAAA.IAAA~BPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAA.YAAAAAAAAAA~1---~CAAAAAAAAABA.QA~BAAAAABA.QA~BAAAABA~BAAAAEA.QA~BAAAAAQA~BAAAAAEA.QA~BAAAAABA~BAAAAABA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAQA.QA~BAAAAABA.QA~BAAAAAAAQA.QA~BAAAAAQA.QA~BAAAAAQA.QA", + "DBACOcGA~CPSG_8APSG_8AAAAAAENAAFgAAAAAAAAAAAAAAAAAAAA.IAAA~BPSG_8APSG_8AAAAAAENAACAAAAAAAAAAAAAAAAAAA.YAAAAAAAAAA~1---~CAAAAAAAAABA.QA~BAAAAABA.QA~BAAAABA~BAAAAEA.QA~BAAAAAQA~BAAAAAEA.QA~BAAAAABA~BAAAAABA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAABAA.QA~BAAAAAQA.QA~BAAAAAQA.QA~BAAAAABA.QA~BAAAAAAAQA.QA~BAAAAAQA.QA~BAAAAAQA.QA~YBAA.AQAA~ZBAA.AQAA~aBAA.AQAA~bBAA.AQAA", gppString); } @@ -452,6 +468,10 @@ public void testDecodeDefaultsAll() { Assertions.assertEquals(true, gppModel.hasSection(UsNj.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsTn.NAME)); Assertions.assertEquals(true, gppModel.hasSection(UsMn.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsIn.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsMd.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsKy.NAME)); + Assertions.assertEquals(true, gppModel.hasSection(UsRi.NAME)); } @Test diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsInTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsInTest.java new file mode 100644 index 0000000..904e1b8 --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsInTest.java @@ -0,0 +1,140 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsInField; +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class UsInTest { + + @Test + public void testEncode1() { + UsIn usIn = new UsIn(); + Assertions.assertEquals("ZBAA.AQAA", usIn.encode()); + } + + @Test + public void testEncode2() { + UsIn usIn = new UsIn(); + + usIn.setFieldValue(UsInField.PROCESSING_NOTICE, 1); + usIn.setFieldValue(UsInField.SALE_OPT_OUT_NOTICE, 1); + usIn.setFieldValue(UsInField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usIn.setFieldValue(UsInField.SALE_OPT_OUT, 1); + usIn.setFieldValue(UsInField.TARGETED_ADVERTISING_OPT_OUT, 1); + usIn.setFieldValue(UsInField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1)); + usIn.setFieldValue(UsInField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 1); + usIn.setFieldValue(UsInField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usIn.setFieldValue(UsInField.MSPA_COVERED_TRANSACTION, 1); + usIn.setFieldValue(UsInField.MSPA_MODE, 1); + usIn.setFieldValue(UsInField.MSPA_VERSION, 1); + + Assertions.assertEquals("ZBABYA.BVVV.kkk", usIn.encode()); + } + + @Test + public void testSetInvalidValues() { + UsIn usIn = new UsIn(); + + try { + usIn.setFieldValue(UsInField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue( + UsInField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usIn.setFieldValue(UsInField.MSPA_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testDecode1() throws DecodingException { + UsIn usIn = new UsIn("ZBABYA.BVVV.kkk"); + + Assertions.assertEquals(1, usIn.getVersion()); + Assertions.assertEquals(1, usIn.getProcessingNotice()); + Assertions.assertEquals(1, usIn.getSaleOptOutNotice()); + Assertions.assertEquals(1, usIn.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usIn.getSaleOptOut()); + Assertions.assertEquals(1, usIn.getTargetedAdvertisingOptOut()); + Assertions.assertEquals( + Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usIn.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usIn.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usIn.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usIn.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usIn.getMspaMode()); + Assertions.assertEquals(1, usIn.getMspaVersion()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows( + DecodingException.class, + () -> { + new UsIn("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsKyTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsKyTest.java new file mode 100644 index 0000000..11d3ad3 --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsKyTest.java @@ -0,0 +1,140 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsKyField; +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class UsKyTest { + + @Test + public void testEncode1() { + UsKy usKy = new UsKy(); + Assertions.assertEquals("aBAA.AQAA", usKy.encode()); + } + + @Test + public void testEncode2() { + UsKy usKy = new UsKy(); + + usKy.setFieldValue(UsKyField.PROCESSING_NOTICE, 1); + usKy.setFieldValue(UsKyField.SALE_OPT_OUT_NOTICE, 1); + usKy.setFieldValue(UsKyField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usKy.setFieldValue(UsKyField.SALE_OPT_OUT, 1); + usKy.setFieldValue(UsKyField.TARGETED_ADVERTISING_OPT_OUT, 1); + usKy.setFieldValue(UsKyField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1)); + usKy.setFieldValue(UsKyField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 1); + usKy.setFieldValue(UsKyField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usKy.setFieldValue(UsKyField.MSPA_COVERED_TRANSACTION, 1); + usKy.setFieldValue(UsKyField.MSPA_MODE, 1); + usKy.setFieldValue(UsKyField.MSPA_VERSION, 1); + + Assertions.assertEquals("aBABYA.BVVV.kkk", usKy.encode()); + } + + @Test + public void testSetInvalidValues() { + UsKy usKy = new UsKy(); + + try { + usKy.setFieldValue(UsKyField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue( + UsKyField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usKy.setFieldValue(UsKyField.MSPA_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testDecode1() throws DecodingException { + UsKy usKy = new UsKy("aBABYA.BVVV.kkk"); + + Assertions.assertEquals(1, usKy.getVersion()); + Assertions.assertEquals(1, usKy.getProcessingNotice()); + Assertions.assertEquals(1, usKy.getSaleOptOutNotice()); + Assertions.assertEquals(1, usKy.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usKy.getSaleOptOut()); + Assertions.assertEquals(1, usKy.getTargetedAdvertisingOptOut()); + Assertions.assertEquals( + Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usKy.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usKy.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usKy.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usKy.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usKy.getMspaMode()); + Assertions.assertEquals(1, usKy.getMspaVersion()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows( + DecodingException.class, + () -> { + new UsKy("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsMdTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsMdTest.java new file mode 100644 index 0000000..8c2748f --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsMdTest.java @@ -0,0 +1,121 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsMdField; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class UsMdTest { + + @Test + public void testEncode1() { + UsMd usMd = new UsMd(); + Assertions.assertEquals("YBAA.AQAA", usMd.encode()); + } + + @Test + public void testEncode2() { + UsMd usMd = new UsMd(); + + usMd.setFieldValue(UsMdField.PROCESSING_NOTICE, 1); + usMd.setFieldValue(UsMdField.SALE_OPT_OUT_NOTICE, 1); + usMd.setFieldValue(UsMdField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usMd.setFieldValue(UsMdField.SALE_OPT_OUT, 1); + usMd.setFieldValue(UsMdField.TARGETED_ADVERTISING_OPT_OUT, 1); + usMd.setFieldValue(UsMdField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usMd.setFieldValue(UsMdField.MSPA_COVERED_TRANSACTION, 1); + usMd.setFieldValue(UsMdField.MSPA_MODE, 1); + usMd.setFieldValue(UsMdField.MSPA_VERSION, 1); + usMd.setFieldValue(UsMdField.GPC, true); + + Assertions.assertEquals("YBABYA.BVVU.YA", usMd.encode()); + } + + @Test + public void testSetInvalidValues() { + UsMd usMd = new UsMd(); + + try { + usMd.setFieldValue(UsMdField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usMd.setFieldValue(UsMdField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usMd.setFieldValue(UsMdField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usMd.setFieldValue(UsMdField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usMd.setFieldValue(UsMdField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usMd.setFieldValue(UsMdField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usMd.setFieldValue(UsMdField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usMd.setFieldValue(UsMdField.MSPA_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testDecode1() throws DecodingException { + UsMd usMd = new UsMd("YBABYA.BVVU.YA"); + + Assertions.assertEquals(1, usMd.getVersion()); + Assertions.assertEquals(1, usMd.getProcessingNotice()); + Assertions.assertEquals(1, usMd.getSaleOptOutNotice()); + Assertions.assertEquals(1, usMd.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usMd.getSaleOptOut()); + Assertions.assertEquals(1, usMd.getTargetedAdvertisingOptOut()); + Assertions.assertEquals(1, usMd.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usMd.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usMd.getMspaMode()); + Assertions.assertEquals(1, usMd.getMspaVersion()); + Assertions.assertEquals(true, usMd.getGpc()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows( + DecodingException.class, + () -> { + new UsMd("z").getProcessingNotice(); + }); + } +} diff --git a/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsRiTest.java b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsRiTest.java new file mode 100644 index 0000000..e5d05c9 --- /dev/null +++ b/iabgpp-encoder/src/test/java/com/iab/gpp/encoder/section/UsRiTest.java @@ -0,0 +1,140 @@ +package com.iab.gpp.encoder.section; + +import com.iab.gpp.encoder.error.DecodingException; +import com.iab.gpp.encoder.error.ValidationException; +import com.iab.gpp.encoder.field.UsRiField; +import java.util.Arrays; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class UsRiTest { + + @Test + public void testEncode1() { + UsRi usRi = new UsRi(); + Assertions.assertEquals("bBAA.AQAA", usRi.encode()); + } + + @Test + public void testEncode2() { + UsRi usRi = new UsRi(); + + usRi.setFieldValue(UsRiField.PROCESSING_NOTICE, 1); + usRi.setFieldValue(UsRiField.SALE_OPT_OUT_NOTICE, 1); + usRi.setFieldValue(UsRiField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 1); + usRi.setFieldValue(UsRiField.SALE_OPT_OUT, 1); + usRi.setFieldValue(UsRiField.TARGETED_ADVERTISING_OPT_OUT, 1); + usRi.setFieldValue(UsRiField.SENSITIVE_DATA_PROCESSING, Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1)); + usRi.setFieldValue(UsRiField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 1); + usRi.setFieldValue(UsRiField.ADDITIONAL_DATA_PROCESSING_CONSENT, 1); + usRi.setFieldValue(UsRiField.MSPA_COVERED_TRANSACTION, 1); + usRi.setFieldValue(UsRiField.MSPA_MODE, 1); + usRi.setFieldValue(UsRiField.MSPA_VERSION, 1); + + Assertions.assertEquals("bBABYA.BVVV.kkk", usRi.encode()); + } + + @Test + public void testSetInvalidValues() { + UsRi usRi = new UsRi(); + + try { + usRi.setFieldValue(UsRiField.PROCESSING_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.SALE_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.TARGETED_ADVERTISING_OPT_OUT_NOTICE, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.SALE_OPT_OUT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.TARGETED_ADVERTISING_OPT_OUT, -1); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue( + UsRiField.SENSITIVE_DATA_PROCESSING, Arrays.asList(0, 1, 2, 3, 1, 2, 0, 1)); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.KNOWN_CHILD_SENSITIVE_DATA_CONSENTS, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.ADDITIONAL_DATA_PROCESSING_CONSENT, 3); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.MSPA_COVERED_TRANSACTION, 0); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + + try { + usRi.setFieldValue(UsRiField.MSPA_MODE, 4); + Assertions.fail("Expected ValidationException"); + } catch (ValidationException e) { + + } + } + + @Test + public void testDecode1() throws DecodingException { + UsRi usRi = new UsRi("bBABYA.BVVV.kkk"); + + Assertions.assertEquals(1, usRi.getVersion()); + Assertions.assertEquals(1, usRi.getProcessingNotice()); + Assertions.assertEquals(1, usRi.getSaleOptOutNotice()); + Assertions.assertEquals(1, usRi.getTargetedAdvertisingOptOutNotice()); + Assertions.assertEquals(1, usRi.getSaleOptOut()); + Assertions.assertEquals(1, usRi.getTargetedAdvertisingOptOut()); + Assertions.assertEquals( + Arrays.asList(2, 1, 0, 2, 1, 0, 2, 1), usRi.getSensitiveDataProcessing()); + Assertions.assertEquals(1, usRi.getKnownChildSensitiveDataConsents()); + Assertions.assertEquals(1, usRi.getAdditionalDataProcessingConsent()); + Assertions.assertEquals(1, usRi.getMspaCoveredTransaction()); + Assertions.assertEquals(1, usRi.getMspaMode()); + Assertions.assertEquals(1, usRi.getMspaVersion()); + } + + @Test() + public void testDecodeGarbage() { + Assertions.assertThrows( + DecodingException.class, + () -> { + new UsRi("z").getProcessingNotice(); + }); + } +}