diff --git a/.eslintrc.json b/.eslintrc.json
index 8a39c344b901af222ecea4c62fb27ec2f452f554..cfec66a7141548f05276c48ed1465981bd98362a 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -10,4 +10,4 @@
     "plugin:@typescript-eslint/eslint-recommended",
     "plugin:@typescript-eslint/recommended"
   ]
-}
\ No newline at end of file
+}
diff --git a/.gitignore b/.gitignore
index d583f868569661cf553b346633dd054dd58e69a1..ef05b8c359c55cf4de00224a476c92f0a6fb1d7d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -612,3 +612,6 @@ $RECYCLE.BIN/
 /.tgitconfig
 
 lib
+junit.xml
+
+.yarn/
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..43d696fe4df24878869152fd90aa13f718e79670
--- /dev/null
+++ b/.gitlab-ci.yml
@@ -0,0 +1,56 @@
+image: node:18.15.0
+
+stages:
+  - test
+
+# === Caches ===
+.yarn-cache: &yarn-cache
+  key: yarn-$CI_JOB_IMAGE
+  paths:
+    - .yarn
+
+# === Proxy ===
+# Description: sets up the proxy needed for the runner inside of the PTB. Produces a build.env that is used in the next jobs
+proxy:
+  stage: .pre
+  script:
+    - touch build.env
+    - if [[ "$CI_RUNNER_TAGS" == *"behind_proxy"* ]]; then
+    -   echo "behind_proxy=true" >> build.env
+    -   echo "http_proxy=http://webproxy.bs.ptb.de:8080/" >> build.env
+    -   echo "https_proxy=http://webproxy.bs.ptb.de:8080/" >> build.env
+    - fi
+  artifacts:
+    reports:
+      dotenv: build.env
+
+
+# === Yarn Install ===
+# Description: installs and caches dependencies
+.yarn-install: &yarn-install
+  - corepack enable
+  # proxy settings
+  - if [[ "$behind_proxy" == true ]]; then
+  -   npm config set proxy $http_proxy
+  -   npm config set https-proxy $https_proxy
+  -   yarn config set -H httpProxy $http_proxy
+  -   yarn config set -H httpsProxy $https_proxy
+  - fi
+  # install deps
+  - yarn install --immutable
+
+# === Job: Unit Tests ===
+# Description: this job runs the unit tests
+test:
+  stage: test
+  needs: ["proxy"]
+  script:
+    - *yarn-install
+    - yarn run test:unit --ci
+  cache:
+    - <<: *yarn-cache
+  artifacts:
+    when: always
+    reports:
+      junit:
+        - junit.xml
diff --git a/.idea/git_toolbox_prj.xml b/.idea/git_toolbox_prj.xml
index b3820067b4c6700f074fd771f517ee5d30b96dc5..bcb1d9dfb2da25e93838cd6b0ba0d64b36910b28 100644
--- a/.idea/git_toolbox_prj.xml
+++ b/.idea/git_toolbox_prj.xml
@@ -11,5 +11,10 @@
         <option name="enabled" value="true" />
       </CommitMessageValidationOverride>
     </option>
+    <option name="commitMessageValidationEnabledOverride">
+      <BoolValueOverride>
+        <option name="enabled" value="true" />
+      </BoolValueOverride>
+    </option>
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000000000000000000000000000000000000..03d9549ea8e4ada36fb3ecbc30fef08175b7d728
--- /dev/null
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+  </profile>
+</component>
\ No newline at end of file
diff --git a/.idea/jsLinters/eslint.xml b/.idea/jsLinters/eslint.xml
new file mode 100644
index 0000000000000000000000000000000000000000..541945bb0819b8ff4a3dae9431632ebd10e6f98b
--- /dev/null
+++ b/.idea/jsLinters/eslint.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="EslintConfiguration">
+    <option name="fix-on-save" value="true" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.yarnrc.yml b/.yarnrc.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3186f3f0795ab612d5508593672dc9ad94bccca0
--- /dev/null
+++ b/.yarnrc.yml
@@ -0,0 +1 @@
+nodeLinker: node-modules
diff --git a/jest.config.ts b/jest.config.ts
new file mode 100644
index 0000000000000000000000000000000000000000..85289d31105bb3e45a8519df5b1137e931185b3e
--- /dev/null
+++ b/jest.config.ts
@@ -0,0 +1,10 @@
+import type { JestConfigWithTsJest } from "ts-jest";
+
+const config: JestConfigWithTsJest = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  reporters: ["default", "jest-junit"],
+  coverageProvider: "v8",
+};
+
+export default config;
diff --git a/package-lock.json b/package-lock.json
deleted file mode 100644
index 5f2c10e590391b41038f3c19919e003c6dacf6c1..0000000000000000000000000000000000000000
Binary files a/package-lock.json and /dev/null differ
diff --git a/package.json b/package.json
index 98f1ca07cd9c58f349dd42e7786a6184706c4496..5e495af069c3ea08c4cb2aaff92ae303ec015d0e 100644
--- a/package.json
+++ b/package.json
@@ -11,31 +11,36 @@
     "fix:prettier": "prettier \"src/**/*.ts\" --write",
     "fix:lint": "eslint src --ext .ts --fix",
     "test": "run-s test:*",
-    "test:unit": "mocha -r ts-node/register tests/**/*.test.ts",
+    "test:unit": "jest",
     "test:lint": "eslint src --ext .ts",
     "test:prettier": "prettier \"src/**/*.ts\" --list-different",
-    "coverage": "nyc -r lcov -e .ts -x \"*.test.ts\" mocha -r ts-node/register tests/**/*.test.ts && nyc report",
-    "prepare": "npm run build",
-    "prepublishOnly": "npm run test",
-    "preversion": "npm run test"
+    "prepare": "yarn run build",
+    "prepublishOnly": "yarn run test",
+    "preversion": "yarn run test"
   },
   "dependencies": {
     "xml-js": "^1.6.11"
   },
   "devDependencies": {
-    "@types/chai": "^4.3.0",
-    "@types/mocha": "^9.1.0",
-    "@typescript-eslint/eslint-plugin": "^5.11.0",
-    "@typescript-eslint/parser": "^5.11.0",
-    "chai": "^4.3.6",
-    "eslint": "^8.8.0",
-    "eslint-config-prettier": "^8.3.0",
-    "mocha": "^9.2.0",
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.1",
+    "@types/node": "^18.16.2",
+    "@typescript-eslint/eslint-plugin": "^5.56.0",
+    "@typescript-eslint/parser": "^5.56.0",
+    "eslint": "^8.36.0",
+    "eslint-config-prettier": "^8.8.0",
+    "fast-check": "^3.7.1",
+    "jest": "^29.5.0",
+    "jest-environment-node": "^29.5.0",
+    "jest-junit": "^16.0.0",
+    "jsdom": "^21.1.1",
+    "lodash": "^4.17.21",
     "npm-run-all": "^4.1.5",
-    "nyc": "^15.1.0",
-    "prettier": "^2.5.1",
-    "ts-node": "^10.5.0",
-    "typescript": "^4.5.5"
+    "prettier": "^2.8.6",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5",
+    "xpath-ts": "^1.3.13"
   },
   "publishConfig": {
     "@d-ptb:registry": "https://gitlab1.ptb.de/api/v4/projects/105/packages/npm/"
@@ -46,5 +51,6 @@
     "!**/*.json",
     "LICENSE",
     "README.md"
-  ]
+  ],
+  "packageManager": "yarn@3.5.0"
 }
diff --git a/tests/Arbitraries.ts b/tests/Arbitraries.ts
new file mode 100644
index 0000000000000000000000000000000000000000..be7453c4d76ade1df354c950981941f1035d85ab
--- /dev/null
+++ b/tests/Arbitraries.ts
@@ -0,0 +1,17 @@
+import * as fc from "fast-check";
+
+export const string_ISO3166_1 = () =>
+  fc
+    .integer({
+      min: "A".charCodeAt(0),
+      max: "Z".charCodeAt(0),
+    })
+    .map(String.fromCharCode);
+
+export const string_ISO639_1 = () =>
+  fc
+    .integer({
+      min: "a".charCodeAt(0),
+      max: "z".charCodeAt(0),
+    })
+    .map(String.fromCharCode);
diff --git a/tests/DCC/AdministrativeData.Items.test.ts b/tests/DCC/AdministrativeData.Items.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..79dfe547c9dd138e496a781666658b6e010ed1e2
--- /dev/null
+++ b/tests/DCC/AdministrativeData.Items.test.ts
@@ -0,0 +1,117 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { ItemType, DCCDocument, IdentificationType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:items";
+const xpath = {
+  items: {
+    item: {
+      name: {
+        content: `${base}/dcc:item[1]/dcc:name/dcc:content`,
+      },
+      manufacturer: {
+        name: {
+          content: `${base}/dcc:item[1]/dcc:manufacturer/dcc:name/dcc:content`,
+        },
+      },
+      model: `string(${base}/dcc:item[1]/dcc:model)`,
+
+      identifications: {
+        identification1: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+          },
+        },
+        identification2: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:name/dcc:content`,
+          },
+        },
+        identification3: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:name/dcc:content`,
+          },
+        },
+      },
+    },
+  },
+};
+
+describe("ItemType", () => {
+  let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
+    identification1 = item.identifications.identification[0];
+    identification2 = item.identifications.identification[1];
+    identification3 = item.identifications.identification[2];
+  });
+
+  test("should get correct item name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.name.content, dom);
+    expect(toTextArr(item.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item manufacturer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.manufacturer.name.content, dom);
+    expect(toTextArr(item.manufacturer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item model from XML", () => {
+    expect(item.model._text).toBe(select(xpath.items.item.model, dom));
+  });
+
+  test("should get correct identification 1 issuer from XML", () => {
+    expect(identification1.issuer._text).toBe(select(xpath.items.item.identifications.identification1.issuer, dom));
+  });
+
+  test("should get correct identification 1 value from XML", () => {
+    expect(identification1.value._text).toBe(select(xpath.items.item.identifications.identification1.value, dom));
+  });
+
+  test("should get correct identification 1 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification1.name.content, dom);
+    expect(toTextArr(identification1.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 2 issuer from XML", () => {
+    expect(identification2.issuer._text).toBe(select(xpath.items.item.identifications.identification2.issuer, dom));
+  });
+
+  test("should get correct identification 2 value from XML", () => {
+    expect(identification2.value._text).toBe(select(xpath.items.item.identifications.identification2.value, dom));
+  });
+
+  test("should get correct identification 2 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification2.name.content, dom);
+    expect(toTextArr(identification2.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 3 issuer from XML", () => {
+    expect(identification3.issuer._text).toBe(select(xpath.items.item.identifications.identification3.issuer, dom));
+  });
+
+  test("should get correct identification 3 value from XML", () => {
+    expect(identification3.value._text).toBe(select(xpath.items.item.identifications.identification3.value, dom));
+  });
+
+  test("should get correct identification 3 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification3.name.content, dom);
+    expect(toTextArr(identification3.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/AdministrativeData.SoftwareListType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6139807094ad603ad938155b8fbf37502d4cef68
--- /dev/null
+++ b/tests/DCC/AdministrativeData.SoftwareListType.test.ts
@@ -0,0 +1,41 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { SoftwareListType, DCCDocument, SoftwareType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:dccSoftware/dcc:software";
+const xpath = {
+  software: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    release: `string(${base}/dcc:release)`,
+    type: `string(${base}/dcc:type)`,
+    description: `${base}/dcc:description`,
+    _id: `${base}/@id`,
+    _refType: `${base}/@refType`,
+  },
+};
+
+describe("DccSoftwareType", () => {
+  let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
+    software = dccSoftware.software[0];
+  });
+
+  test("should get correct software name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.software.name.content, dom);
+    expect(toTextArr(software.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct software release version of software from XML", () => {
+    expect(software.release._text).toBe(select(xpath.software.release, dom));
+  });
+});
diff --git a/tests/DCC/AdministrativeData.test.ts b/tests/DCC/AdministrativeData.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b6f6aded6f213f7e171ac2cf52a9def678df1257
--- /dev/null
+++ b/tests/DCC/AdministrativeData.test.ts
@@ -0,0 +1,19 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { testCalibrationLaboratory } from "./common/AdministrativeData/CalibrationLaboratory";
+import { testCoreData } from "./common/AdministrativeData/CoreDataType";
+import { testContactType } from "./common/Types/ContactType";
+import { testRespPersonListType } from "./common/AdministrativeData/RespPersons";
+import { testStatementListType } from "./common/Types/StatementListType";
+
+describe(`[example.xml] AdministrativeData`, () => {
+  const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData";
+  testCalibrationLaboratory();
+  testCoreData();
+  testContactType(`${base}/dcc:customer`, (dcc) => dcc.digitalCalibrationCertificate.administrativeData.customer);
+  testRespPersonListType();
+  testStatementListType(`${base}/dcc:statements`, (dcc) => dcc.digitalCalibrationCertificate.administrativeData.statements);
+});
diff --git a/tests/DCC/DigitalCalibrationCertificateType.test.ts b/tests/DCC/DigitalCalibrationCertificateType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eaceec37e2432ea659fed9d601e3fd818e3cb15a
--- /dev/null
+++ b/tests/DCC/DigitalCalibrationCertificateType.test.ts
@@ -0,0 +1,21 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select } from "../util";
+
+const VERSION_XPATH = "string(/dcc:digitalCalibrationCertificate/@schemaVersion)";
+
+describe("DigitalCalibrationCertificateType", () => {
+  let xml, dcc, dom;
+
+  beforeEach(() => {
+    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+  });
+
+  test("should get correct schemaVersion from XML", () => {
+    const expectedVersion = select(VERSION_XPATH, dom);
+    expect(dcc.digitalCalibrationCertificate._attr.schemaVersion).toBe(expectedVersion);
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0bf3cced84adb6649cfe6610c7c14b87d1f11c72
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
@@ -0,0 +1,84 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { CalibrationLaboratoryType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:calibrationLaboratory/dcc:contact";
+const xpath = {
+  name: `string(${base}/dcc:name/dcc:content)`,
+  eMail: `string(${base}/dcc:eMail)`,
+  phone: `string(${base}/dcc:phone)`,
+  fax: `string(${base}/dcc:fax)`,
+  location: {
+    city: `${base}/dcc:location/dcc:city`,
+    countryCode: `${base}/dcc:location/dcc:countryCode`,
+    postCode: `${base}/dcc:location/dcc:postCode`,
+    street: `${base}/dcc:location/dcc:street`,
+    streetNo: `${base}/dcc:location/dcc:streetNo`,
+    further: `${base}/dcc:location/dcc:further/dcc:content`,
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: CalibrationLaboratoryType", () => {
+  let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
+  });
+
+  test("should get correct name from XML", () => {
+    expect(calibrationLaboratory.contact.name.content[0]._text).toBe(select(xpath.name, dom));
+  });
+
+  test("should get correct eMail from XML", () => {
+    expect(calibrationLaboratory.contact.eMail._text).toBe(select(xpath.eMail, dom));
+  });
+
+  test("should get correct phone from XML", () => {
+    expect(calibrationLaboratory.contact.phone._text).toBe(select(xpath.phone, dom));
+  });
+
+  test("should get correct fax from XML", () => {
+    expect(calibrationLaboratory.contact.fax._text).toBe(select(xpath.fax, dom));
+  });
+
+  test("should get correct city from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.city, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.city)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct countryCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.countryCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.countryCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct postCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.postCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.postCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct street from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.street, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.street)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct streetNo from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.streetNo, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.streetNo)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct further element from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.further, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.further[0].content)).toEqual(toTextContentArr(expected));
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0c3aaf0e342ccba99f5008b24a05d90f3b203562
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
@@ -0,0 +1,118 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import * as fc from "fast-check";
+import { indexOf, select, toTextArr, toTextContentArr } from "../../util";
+import { CoreDataType, DCCDocument, DCCXMLElement } from "../../../src";
+import { string_ISO639_1 } from "../../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:coreData";
+const xpath = {
+  coreData: {
+    countryCodeISO3166_1: `string(${base}/dcc:countryCodeISO3166_1)`,
+    usedLangCodeISO639_1: `${base}/dcc:usedLangCodeISO639_1`,
+    mandatoryLangCodeISO639_1: `${base}/dcc:mandatoryLangCodeISO639_1`,
+    uniqueIdentifier: `string(${base}/dcc:uniqueIdentifier)`,
+    identifications: {
+      identification: {
+        issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+        value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        name: {
+          content: `${base}/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+        },
+      },
+    },
+    beginPerformanceDate: `string(${base}/dcc:beginPerformanceDate)`,
+    endPerformanceDate: `string(${base}/dcc:endPerformanceDate)`,
+    performanceLocation: `string(${base}/dcc:performanceLocation)`,
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: CoreDataType", () => {
+  let dcc: DCCDocument, coreData: CoreDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
+  });
+
+  test("should get correct countryCodeISO3166_1 from XML", () => {
+    expect(coreData.countryCodeISO3166_1._text).toBe(select(xpath.coreData.countryCodeISO3166_1, dom));
+  });
+
+  test("should get correct usedLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.usedLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct mandatoryLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.mandatoryLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.mandatoryLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct unique identifier from XML", () => {
+    expect(coreData.uniqueIdentifier._text).toBe(select(xpath.coreData.uniqueIdentifier, dom));
+  });
+
+  test("should get correct identification issuer from XML", () => {
+    expect(coreData.identifications.identification[0].issuer._text).toBe(select(xpath.coreData.identifications.identification.issuer, dom));
+  });
+
+  test("should get correct identification value from XML", () => {
+    expect(coreData.identifications.identification[0].value._text).toBe(select(xpath.coreData.identifications.identification.value, dom));
+  });
+
+  test("should get correct identification name content from XML", () => {
+    const expected = <Element[]>select(xpath.coreData.identifications.identification.name.content, dom);
+    expect(toTextArr(coreData.identifications.identification[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct begin performance date from XML", () => {
+    expect(coreData.beginPerformanceDate._text).toBe(select(xpath.coreData.beginPerformanceDate, dom));
+  });
+
+  test("should get correct end performance date from XML", () => {
+    expect(coreData.endPerformanceDate._text).toBe(select(xpath.coreData.endPerformanceDate, dom));
+  });
+
+  test("should get correct performance location from XML", () => {
+    expect(coreData.performanceLocation._text).toBe(select(xpath.coreData.performanceLocation, dom));
+  });
+
+  /* test for setters */
+  test("should set usedLangCodeISO639_1 correctly", () => {
+    fc.assert(
+      fc.property(string_ISO639_1(), (str) => {
+        // add new element to array
+        coreData.usedLangCodeISO639_1.push(new DCCXMLElement({ _text: str }));
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).toContain(str);
+        expect(toTextContentArr(actual)).toContain(str);
+      }),
+    );
+  });
+
+  test("should delete usedLangCodeISO639_1 correctly", () => {
+    const selection = toTextContentArr(<Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom));
+    fc.assert(
+      fc.property(fc.constantFrom(...selection), (str) => {
+        // get index and remove element from array
+        const index = indexOf(coreData.usedLangCodeISO639_1, str);
+        coreData.usedLangCodeISO639_1.splice(index, 1);
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).not.toContain(str);
+        expect(toTextContentArr(actual)).not.toContain(str);
+      }),
+    );
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99bc252bd9f99c08f901d64d63228d5d26390dcf
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
@@ -0,0 +1,70 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ContactType, DCCDocument, LocationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:customer";
+const xpath = {
+  customer: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    email: `string(${base}/dcc:eMail)`,
+    location: {
+      city: `${base}/dcc:location/dcc:city[1]`,
+      countryCode: `${base}/dcc:location/dcc:countryCode[1]`,
+      postCode: `${base}/dcc:location/dcc:postCode[1]`,
+      further: `${base}/dcc:location/dcc:further[1]/dcc:content`,
+    },
+    descriptionData: `${base}/dcc:descriptionData`,
+    _id: `${base}/@id`,
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: ContactType", () => {
+  let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
+    location = customer.location; /* TODO: check iff this variable is used anywhere */
+  });
+
+  test("should get correct customer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.customer.name.content, dom);
+    expect(toTextArr(customer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct customer email address from XML", () => {
+    expect(customer.eMail._text).toBe(select(xpath.customer.email, dom));
+  });
+
+  test("should get correct customer location city from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.city, dom);
+    expect(customer.location.city[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location county code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.countryCode, dom);
+    expect(customer.location.countryCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location post code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.postCode, dom);
+    expect(customer.location.postCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location further from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.further, dom);
+
+    for (let i = 0; i < expected.length; i++) {
+      expect(customer.location.further[0].content[i]._text).toBe(expected[i].textContent);
+    }
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..66f37cfb0794bc77eb7fb21789c32294426879a7
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
@@ -0,0 +1,117 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ItemType, DCCDocument, IdentificationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:items";
+const xpath = {
+  items: {
+    item: {
+      name: {
+        content: `${base}/dcc:item[1]/dcc:name/dcc:content`,
+      },
+      manufacturer: {
+        name: {
+          content: `${base}/dcc:item[1]/dcc:manufacturer/dcc:name/dcc:content`,
+        },
+      },
+      model: `string(${base}/dcc:item[1]/dcc:model)`,
+
+      identifications: {
+        identification1: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+          },
+        },
+        identification2: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:name/dcc:content`,
+          },
+        },
+        identification3: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:name/dcc:content`,
+          },
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: ItemType", () => {
+  let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
+    identification1 = item.identifications.identification[0];
+    identification2 = item.identifications.identification[1];
+    identification3 = item.identifications.identification[2];
+  });
+
+  test("should get correct item name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.name.content, dom);
+    expect(toTextArr(item.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item manufacturer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.manufacturer.name.content, dom);
+    expect(toTextArr(item.manufacturer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item model from XML", () => {
+    expect(item.model._text).toBe(select(xpath.items.item.model, dom));
+  });
+
+  test("should get correct identification 1 issuer from XML", () => {
+    expect(identification1.issuer._text).toBe(select(xpath.items.item.identifications.identification1.issuer, dom));
+  });
+
+  test("should get correct identification 1 value from XML", () => {
+    expect(identification1.value._text).toBe(select(xpath.items.item.identifications.identification1.value, dom));
+  });
+
+  test("should get correct identification 1 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification1.name.content, dom);
+    expect(toTextArr(identification1.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 2 issuer from XML", () => {
+    expect(identification2.issuer._text).toBe(select(xpath.items.item.identifications.identification2.issuer, dom));
+  });
+
+  test("should get correct identification 2 value from XML", () => {
+    expect(identification2.value._text).toBe(select(xpath.items.item.identifications.identification2.value, dom));
+  });
+
+  test("should get correct identification 2 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification2.name.content, dom);
+    expect(toTextArr(identification2.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 3 issuer from XML", () => {
+    expect(identification3.issuer._text).toBe(select(xpath.items.item.identifications.identification3.issuer, dom));
+  });
+
+  test("should get correct identification 3 value from XML", () => {
+    expect(identification3.value._text).toBe(select(xpath.items.item.identifications.identification3.value, dom));
+  });
+
+  test("should get correct identification 3 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification3.name.content, dom);
+    expect(toTextArr(identification3.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8d52086066b11d641bbc1108e37aa7b8b58107b1
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
@@ -0,0 +1,56 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { RespPersonType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:respPersons";
+const xpath = {
+  respPersons: {
+    respPerson1: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[1]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+      mainSigner: `string(${base}/dcc:respPerson[1]/dcc:mainSigner)`,
+    },
+    respPerson2: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[2]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: RespPersonType", () => {
+  let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
+    respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
+  });
+
+  test("should get correct responsible person 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson1.person.name.content, dom);
+    expect(toTextArr(respPerson1.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct responsible person 1 main signer flag from XML", () => {
+    expect(respPerson1.mainSigner._text).toBe(select(xpath.respPersons.respPerson1.mainSigner, dom));
+  });
+
+  test("should get correct responsible person 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson2.person.name.content, dom);
+    expect(toTextArr(respPerson2.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb27ba6f77573b755794f2bb03ffbf92ec759cd2
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
@@ -0,0 +1,37 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { SoftwareListType, DCCDocument, SoftwareType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:dccSoftware/dcc:software";
+const xpath = {
+  software: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    release: `string(${base}/dcc:release)`,
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: DccSoftwareType", () => {
+  let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
+    software = dccSoftware.software[0];
+  });
+
+  test("should get correct software name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.software.name.content, dom);
+    expect(toTextArr(software.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct software release version of software from XML", () => {
+    expect(software.release._text).toBe(select(xpath.software.release, dom));
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f68a629de17b2ad994e5ba10de64dd75e4d02f18
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
@@ -0,0 +1,127 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { StatementMetaDataType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:statements";
+const xpath = {
+  statements: {
+    statement1: {
+      declaration: {
+        content: `${base}/dcc:statement[1]/dcc:declaration/dcc:content`,
+      },
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[1]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:eMail)`,
+        location: {
+          city: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      conformity: `string(${base}/dcc:statement[1]/dcc:conformity)`,
+      refType: `string(${base}/dcc:statement[1]/@refType)`,
+    },
+    statement2: {
+      declaration: {
+        content: `${base}/dcc:statement[2]/dcc:declaration/dcc:content`,
+      },
+      date: `string(${base}/dcc:statement[2]/dcc:date)`,
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[2]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:eMail)`,
+        location: {
+          city: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      refType: `string(${base}/dcc:statement[2]/@refType)`,
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: StatementMetaDataType", () => {
+  let dcc: DCCDocument, statement1, statement2: StatementMetaDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
+    statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
+  });
+
+  test("should get correct statement 1 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement1.declaration.content, dom);
+    expect(toTextArr(statement1.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* responsible authority 1 */
+  test("should get correct statement 1 responsible authority name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement1.respAuthority.name.content, dom);
+    expect(toTextArr(statement1.respAuthority.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 1 responsible authority email from XML", () => {
+    expect(statement1.respAuthority.eMail._text).toBe(select(xpath.statements.statement1.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 1 responsible authority location city from XML", () => {
+    expect(statement1.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement1.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 1 responsible authority location country code from XML", () => {
+    expect(statement1.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement1.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 1 responsible authority location post code from XML", () => {
+    expect(statement1.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement1.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 1 conformity from XML", () => {
+    expect(statement1.conformity._text).toBe(select(xpath.statements.statement1.conformity, dom));
+  });
+
+  test("should get correct statement 2 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.declaration.content, dom);
+    expect(toTextArr(statement2.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 refType from XML", () => {
+    expect(statement2.date._text).toBe(select(xpath.statements.statement2.date, dom));
+  });
+
+  /* responsible authority 2 */
+  test("should get correct statement 2 responsible authority name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.respAuthority.name.content, dom);
+    expect(toTextArr(statement2.respAuthority.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 responsible authority email from XML", () => {
+    expect(statement2.respAuthority.eMail._text).toBe(select(xpath.statements.statement2.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 2 responsible authority location city from XML", () => {
+    expect(statement2.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement2.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 2 responsible authority location country code from XML", () => {
+    expect(statement2.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement2.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 2 responsible authority location post code from XML", () => {
+    expect(statement2.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement2.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 2 refType from XML", () => {
+    expect(statement2._attr.refType).toBe(select(xpath.statements.statement2.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df17932841adeec6409042ea38cd0f3a381580aa
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
@@ -0,0 +1,21 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select } from "../../util";
+
+const VERSION_XPATH = "string(/dcc:digitalCalibrationCertificate/@schemaVersion)";
+
+describe("GP_DCC_Temperature_Simplified: DigitalCalibrationCertificateType", () => {
+  let xml, dcc, dom;
+
+  beforeEach(() => {
+    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+  });
+
+  test("should get correct schemaVersion from XML", () => {
+    const expectedVersion = select(VERSION_XPATH, dom);
+    expect(dcc.digitalCalibrationCertificate._attr.schemaVersion).toBe(expectedVersion);
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f989c1d20662108888caf7d4142a4b4ddcd39a31
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -0,0 +1,218 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, InfluenceConditionListType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:influenceConditions";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      influenceConditions: {
+        influenceCondition1: {
+          name: {
+            content: `${base}/dcc:influenceCondition[1]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[1]/dcc:description/dcc:content`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[1]//@refType)`,
+        },
+        influenceCondition2: {
+          name: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='en']`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[2]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: InfluenceConditionListType", () => {
+  let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
+  });
+
+  test("should get correct influence condition 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d130350529ce3a5100676c939221b0735859e659
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -0,0 +1,58 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, MeasuringEquipmentType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:measuringEquipments/dcc:measuringEquipment[1]";
+const xpath = {
+  measuringEquipments: {
+    measuringEquipment: {
+      name: {
+        content: `${base}/dcc:name/dcc:content`,
+      },
+      identifications: {
+        identification: {
+          issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        },
+      },
+      refType: `string(${base}//@refType)`,
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: MeasuringEquipmentType", () => {
+  let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measuringEquipments.measuringEquipment.name.content, dom);
+    expect(toTextArr(measuringEquipment.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct measuring equipment 1 identification issuer from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].issuer._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.issuer, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 identification value from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].value._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.value, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 refType from XML", () => {
+    expect(measuringEquipment._attr.refType).toBe(select(xpath.measuringEquipments.measuringEquipment.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6fad3dfb600c799b1db5e64e14b41b8adb15a948
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
@@ -0,0 +1,35 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, MeasurementResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      name: {
+        content: `${base}/dcc:measurementResult[1]/dcc:name/dcc:content`,
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: MeasurementResultType", () => {
+  let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.name.content, dom);
+    expect(toTextArr(measurementResult.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4fd76812bb8ddd98fbf6ccf6f87d55947b72812a
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
@@ -0,0 +1,339 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, ResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:results";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      results: {
+        result: {
+          name: {
+            content: `${base}/dcc:result[1]/dcc:name/dcc:content`,
+          },
+          data: {
+            list: {
+              quantity1: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]//@refType)`,
+              },
+              quantity2: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]//@refType)`,
+              },
+              quantity3: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:name/dcc:content`,
+                },
+                si_realListXMLList: {
+                  si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:valueXMLList)`,
+                  si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:unitXMLList)`,
+                  si_expandedUncXMLList: {
+                    si_uncertaintyXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:uncertaintyXMLList)`,
+                    si_coverageFactorXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageFactorXMLList)`,
+                    si_coverageProbabilityXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageProbabilityXMLList)`,
+                    si_distributionXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:distributionXMLList)`,
+                  },
+                },
+                measurementMetaData: {
+                  metaData: {
+                    declaration: {
+                      name: {
+                        content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData[1]/dcc:declaration/dcc:name/dcc:content`,
+                      },
+                    },
+                    conformityXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:conformityXMLList)`,
+                    data: {
+                      quantity1: {
+                        si_realListXMLList: {
+                          si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:realListXMLList/si:valueXMLList)`,
+                          si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:realListXMLList/si:unitXMLList)`,
+                        },
+                        refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]//@refType)`,
+                      },
+                      quantity2: {
+                        si_realListXMLList: {
+                          si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[2]/si:realListXMLList/si:valueXMLList)`,
+                          si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[2]/si:realListXMLList/si:unitXMLList)`,
+                        },
+                        refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[2]//@refType)`,
+                      },
+                    },
+                    refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData//@refType)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/@refType)`,
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:result[1]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: ResultType", () => {
+  let dcc: DCCDocument, result: ResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
+  });
+
+  test("should get correct result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.name.content, dom);
+    expect(toTextArr(result.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:unitXMLList 2: from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 2 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:unitXMLList 2: from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[2].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 3 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.uncertaintyXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_uncertaintyXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty coverage factor list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageFactorXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageFactorXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty coverage probability list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageProbabilityXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageProbabilityXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty distribution list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.distributionXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_distributionXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 meta data declaration name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.declaration.name.content, dom)
+    );
+    expect(toTextArr(result.data.list[0].quantity[2].measurementMetaData.metaData[0].declaration.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 3 meta data conformityXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].conformityXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.conformityXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 meta data quantity 1 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[0].realListXMLList.valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity1.si_realListXMLList
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 meta data quantity 1 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[0].realListXMLList.unitXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity1.si_realListXMLList
+          .si_unitXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 meta data quantity 2 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[1].realListXMLList.valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity2.si_realListXMLList
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 meta data quantity 2 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[1].realListXMLList.valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity2.si_realListXMLList
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 meta data quantity 2 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[1].realListXMLList.unitXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity2.si_realListXMLList
+          .si_unitXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result refType from XML", () => {
+    expect(result._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.refType, dom));
+  });
+
+  test("should get correct result data list refType from XML", () => {
+    expect(result.data.list[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.list.refType, dom));
+  });
+
+  test("should get correct result quantity 1 refType from XML", () => {
+    expect(result.data.list[0].quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity2 refType from XML", () => {
+    expect(result.data.list[0].quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity3 refType from XML", () => {
+    expect(result.data.list[0].quantity[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 meta data refType from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 refType from XML", () => {
+    expect(result.data.list[0].quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 refType from XML", () => {
+    expect(result.data.list[0].quantity[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6becd0f772fca196b423bf989e7f3fb04b2aae75
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -0,0 +1,44 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, UsedMethodListType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      usedMethods: {
+        usedMethod1: {
+          name: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:name/dcc:content`,
+          },
+          refType: `string(${base}/dcc:usedMethods/dcc:usedMethod[1]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: UsedMethodListType", () => {
+  let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
+  });
+
+  test("should get correct used method 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.name.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 1 refType from XML", () => {
+    expect(usedMethods.usedMethod[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..de4e31006f2e0a79a16e2d3571aa462fe65d2e28
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
@@ -0,0 +1,37 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified_variant.xml
+ */
+
+import { select } from "../../util";
+import { ItemType, DCCDocument, EquipmentClassType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:items";
+const xpath = {
+  items: {
+    item: {
+      equipmentClass: {
+        reference: `string(${base}/dcc:item[1]/dcc:equipmentClass[1]/dcc:reference)`,
+        classID: `string(${base}/dcc:item[1]/dcc:equipmentClass[1]/dcc:classID)`,
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: ItemType", () => {
+  let dcc: DCCDocument, item: ItemType, equipmentClass: EquipmentClassType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
+    equipmentClass = item.equipmentClass[0];
+  });
+
+  test("should get correct equipmentClass reference from XML", () => {
+    expect(equipmentClass.reference._text).toBe(select(xpath.items.item.equipmentClass.reference, dom));
+  });
+
+  test("should get correct equipmentClass classID from XML", () => {
+    expect(equipmentClass.classID._text).toBe(select(xpath.items.item.equipmentClass.classID, dom));
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..26ad9a3656a417a6d9a2f666be1b254f136ca85b
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
@@ -0,0 +1,95 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Simplified_variant.xml
+ */
+
+import * as fc from "fast-check";
+import { select, toTextArr, toTextContentArr, indexOf } from "../../util";
+import { StatementMetaDataType, DCCDocument, DCCXMLElement } from "../../../src";
+import { string_ISO3166_1 } from "../../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:statements";
+const xpath = {
+  statements: {
+    statement3: {
+      countryCodeISO3166_1: `${base}/dcc:statement[3]/dcc:countryCodeISO3166_1`,
+      convention: `string(${base}/dcc:statement[3]/dcc:convention)`,
+      traceable: `string(${base}/dcc:statement[3]/dcc:traceable)`,
+      period: `string(${base}/dcc:statement[3]/dcc:period)`,
+      nonSIDefinition: `string(${base}/dcc:statement[3]/dcc:nonSIDefinition)`,
+      nonSIUnit: `string(${base}/dcc:statement[3]/dcc:nonSIUnit)`,
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Simplified: StatementMetaDataType", () => {
+  let dcc: DCCDocument, statement3: StatementMetaDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
+  });
+
+  test("should get correct statement 3 countryCodeISO3166_1 from XML", () => {
+    const expected = <Element[]>select(xpath.statements.statement3.countryCodeISO3166_1, dom);
+    expect(toTextArr(statement3.countryCodeISO3166_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 3 convention from XML", () => {
+    const expected = select(xpath.statements.statement3.convention, dom);
+    expect(statement3.convention._text).toEqual(expected);
+  });
+
+  test("should get correct statement 3 traceable from XML", () => {
+    const expected = select(xpath.statements.statement3.traceable, dom);
+    expect(statement3.traceable._text).toEqual(expected);
+  });
+
+  test("should get correct statement 3 period from XML", () => {
+    const expected = select(xpath.statements.statement3.period, dom);
+    expect(statement3.period._text).toEqual(expected);
+  });
+
+  test("should get correct statement 3 nonSIDefinition from XML", () => {
+    const expected = select(xpath.statements.statement3.nonSIDefinition, dom);
+    expect(statement3.nonSIDefinition._text).toEqual(expected);
+  });
+
+  test("should get correct statement 3 nonSIUnit from XML", () => {
+    const expected = select(xpath.statements.statement3.nonSIUnit, dom);
+    expect(statement3.nonSIUnit._text).toEqual(expected);
+  });
+
+  /* test for setters */
+  test("should set statement 3 countryCodeISO3166_1 correctly", () => {
+    fc.assert(
+      fc.property(string_ISO3166_1(), (str) => {
+        // add new element to array
+        statement3.countryCodeISO3166_1.push(new DCCXMLElement({ _text: str }));
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.statements.statement3.countryCodeISO3166_1, dcc);
+
+        expect(toTextArr(statement3.countryCodeISO3166_1)).toContain(str);
+        expect(toTextContentArr(actual)).toContain(str);
+      }),
+    );
+  });
+
+  test("should delete statement 3 countryCodeISO3166_1 correctly", () => {
+    const selection = toTextContentArr(<Element[]>select(xpath.statements.statement3.countryCodeISO3166_1, dom));
+    fc.assert(
+      fc.property(fc.constantFrom(...selection), (str) => {
+        // get index and remove element from array
+        const index = indexOf(statement3.countryCodeISO3166_1, str);
+        statement3.countryCodeISO3166_1.splice(index, 1);
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.statements.statement3.countryCodeISO3166_1, dcc);
+
+        expect(toTextArr(statement3.countryCodeISO3166_1)).not.toContain(str);
+        expect(toTextContentArr(actual)).not.toContain(str);
+      }),
+    );
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fdaf96a8e5330b63bdd61a090a4d7596711ef0c5
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
@@ -0,0 +1,80 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { CalibrationLaboratoryType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:calibrationLaboratory/dcc:contact";
+const xpath = {
+  name: `string(${base}/dcc:name/dcc:content)`,
+  eMail: `string(${base}/dcc:eMail)`,
+  phone: `string(${base}/dcc:phone)`,
+  fax: `string(${base}/dcc:fax)`,
+  location: {
+    city: `${base}/dcc:location/dcc:city`,
+    countryCode: `${base}/dcc:location/dcc:countryCode`,
+    postCode: `${base}/dcc:location/dcc:postCode`,
+    street: `${base}/dcc:location/dcc:street`,
+    streetNo: `${base}/dcc:location/dcc:streetNo`,
+    further: `${base}/dcc:location/dcc:further/dcc:content`,
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: CalibrationLaboratoryType", () => {
+  let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
+  });
+
+  test("should get correct name from XML", () => {
+    expect(calibrationLaboratory.contact.name.content[0]._text).toBe(select(xpath.name, dom));
+  });
+
+  test("should get correct eMail from XML", () => {
+    expect(calibrationLaboratory.contact.eMail._text).toBe(select(xpath.eMail, dom));
+  });
+
+  test("should get correct phone from XML", () => {
+    expect(calibrationLaboratory.contact.phone._text).toBe(select(xpath.phone, dom));
+  });
+
+  test("should get correct city from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.city, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.city)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct countryCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.countryCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.countryCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct postCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.postCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.postCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct street from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.street, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.street)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct streetNo from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.streetNo, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.streetNo)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct further element from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.further, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.further[0].content)).toEqual(toTextContentArr(expected));
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..da8c8eef5bfb4a343e752de85d788c50f86da66c
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
@@ -0,0 +1,120 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import * as fc from "fast-check";
+import { indexOf, select, toTextArr, toTextContentArr } from "../../util";
+import { CoreDataType, DCCDocument, DCCXMLElement } from "../../../src";
+import { string_ISO639_1 } from "../../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:coreData";
+const xpath = {
+  coreData: {
+    countryCodeISO3166_1: `string(${base}/dcc:countryCodeISO3166_1)`,
+    usedLangCodeISO639_1: `${base}/dcc:usedLangCodeISO639_1`,
+    mandatoryLangCodeISO639_1: `${base}/dcc:mandatoryLangCodeISO639_1`,
+    uniqueIdentifier: `string(${base}/dcc:uniqueIdentifier)`,
+    identifications: {
+      identification: {
+        issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+        value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        name: {
+          content: `${base}/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+        },
+      },
+    },
+    receiptDate: `string(${base}/dcc:receiptDate)`,
+    beginPerformanceDate: `string(${base}/dcc:beginPerformanceDate)`,
+    endPerformanceDate: `string(${base}/dcc:endPerformanceDate)`,
+    performanceLocation: `string(${base}/dcc:performanceLocation)`,
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: CoreDataType", () => {
+  let dcc: DCCDocument, coreData: CoreDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
+  });
+
+  test("should get correct countryCodeISO3166_1 from XML", () => {
+    expect(coreData.countryCodeISO3166_1._text).toBe(select(xpath.coreData.countryCodeISO3166_1, dom));
+  });
+
+  test("should get correct usedLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.usedLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct mandatoryLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.mandatoryLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.mandatoryLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct unique identifier from XML", () => {
+    expect(coreData.uniqueIdentifier._text).toBe(select(xpath.coreData.uniqueIdentifier, dom));
+  });
+
+  test("should get correct identification issuer from XML", () => {
+    expect(coreData.identifications.identification[0].issuer._text).toBe(select(xpath.coreData.identifications.identification.issuer, dom));
+  });
+
+  test("should get correct identification value from XML", () => {
+    expect(coreData.identifications.identification[0].value._text).toBe(select(xpath.coreData.identifications.identification.value, dom));
+  });
+
+  test("should get correct identification name content from XML", () => {
+    const expected = <Element[]>select(xpath.coreData.identifications.identification.name.content, dom);
+    expect(toTextArr(coreData.identifications.identification[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct receipt date from XML", () => {
+    expect(coreData.receiptDate._text).toBe(select(xpath.coreData.receiptDate, dom));
+  });
+  test("should get correct begin performance date from XML", () => {
+    expect(coreData.beginPerformanceDate._text).toBe(select(xpath.coreData.beginPerformanceDate, dom));
+  });
+  test("should get correct end performance date from XML", () => {
+    expect(coreData.endPerformanceDate._text).toBe(select(xpath.coreData.endPerformanceDate, dom));
+  });
+  test("should get correct performance location from XML", () => {
+    expect(coreData.performanceLocation._text).toBe(select(xpath.coreData.performanceLocation, dom));
+  });
+
+  /* test for setters */
+  test("should set usedLangCodeISO639_1 correctly", () => {
+    fc.assert(
+      fc.property(string_ISO639_1(), (str) => {
+        // add new element to array
+        coreData.usedLangCodeISO639_1.push(new DCCXMLElement({ _text: str }));
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).toContain(str);
+        expect(toTextContentArr(actual)).toContain(str);
+      }),
+    );
+  });
+
+  test("should delete usedLangCodeISO639_1 correctly", () => {
+    const selection = toTextContentArr(<Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom));
+    fc.assert(
+      fc.property(fc.constantFrom(...selection), (str) => {
+        // get index and remove element from array
+        const index = indexOf(coreData.usedLangCodeISO639_1, str);
+        coreData.usedLangCodeISO639_1.splice(index, 1);
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).not.toContain(str);
+        expect(toTextContentArr(actual)).not.toContain(str);
+      }),
+    );
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e03dd5c937697249483c739b4f8ab0ab4390b744
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
@@ -0,0 +1,77 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ContactType, DCCDocument, LocationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:customer";
+const xpath = {
+  customer: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    email: `string(${base}/dcc:eMail)`,
+    phone: `string(${base}/dcc:phone)`,
+    fax: `string(${base}/dcc:fax)`,
+    location: {
+      city: `${base}/dcc:location/dcc:city[1]`,
+      countryCode: `${base}/dcc:location/dcc:countryCode[1]`,
+      postCode: `${base}/dcc:location/dcc:postCode[1]`,
+      postBoxOffice: `${base}/dcc:location/dcc:postBoxOffice[1]`,
+      state: `${base}/dcc:location/dcc:state[1]`,
+      street: `${base}/dcc:location/dcc:street[1]`,
+      streetNo: `${base}/dcc:location/dcc:streetNo[1]`,
+      further: `${base}/dcc:location/dcc:further[1]/dcc:content`,
+      positionCoordinates: `${base}/dcc:location/dcc:positionCoordinates[1]`,
+    },
+    descriptionData: `${base}/dcc:descriptionData`,
+    _id: `${base}/@id`,
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: ContactType", () => {
+  let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
+    location = customer.location; /* TODO: check iff this variable is used anywhere */
+  });
+
+  test("should get correct customer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.customer.name.content, dom);
+    expect(toTextArr(customer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct customer email address from XML", () => {
+    expect(customer.eMail._text).toBe(select(xpath.customer.email, dom));
+  });
+
+  test("should get correct customer location city from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.city, dom);
+    expect(customer.location.city[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location county code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.countryCode, dom);
+    expect(customer.location.countryCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location post code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.postCode, dom);
+    expect(customer.location.postCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location further from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.further, dom);
+
+    for (let i = 0; i < expected.length; i++) {
+      expect(customer.location.further[0].content[i]._text).toBe(expected[i].textContent);
+    }
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dce1bac30f28aff286bee030f6e18e635c311e35
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
@@ -0,0 +1,117 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ItemType, DCCDocument, IdentificationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:items";
+const xpath = {
+  items: {
+    item: {
+      name: {
+        content: `${base}/dcc:item[1]/dcc:name/dcc:content`,
+      },
+      manufacturer: {
+        name: {
+          content: `${base}/dcc:item[1]/dcc:manufacturer/dcc:name/dcc:content`,
+        },
+      },
+      model: `string(${base}/dcc:item[1]/dcc:model)`,
+
+      identifications: {
+        identification1: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+          },
+        },
+        identification2: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:name/dcc:content`,
+          },
+        },
+        identification3: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:name/dcc:content`,
+          },
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: ItemType", () => {
+  let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
+    identification1 = item.identifications.identification[0];
+    identification2 = item.identifications.identification[1];
+    identification3 = item.identifications.identification[2];
+  });
+
+  test("should get correct item name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.name.content, dom);
+    expect(toTextArr(item.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item manufacturer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.manufacturer.name.content, dom);
+    expect(toTextArr(item.manufacturer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item model from XML", () => {
+    expect(item.model._text).toBe(select(xpath.items.item.model, dom));
+  });
+
+  test("should get correct identification 1 issuer from XML", () => {
+    expect(identification1.issuer._text).toBe(select(xpath.items.item.identifications.identification1.issuer, dom));
+  });
+
+  test("should get correct identification 1 value from XML", () => {
+    expect(identification1.value._text).toBe(select(xpath.items.item.identifications.identification1.value, dom));
+  });
+
+  test("should get correct identification 1 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification1.name.content, dom);
+    expect(toTextArr(identification1.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 2 issuer from XML", () => {
+    expect(identification2.issuer._text).toBe(select(xpath.items.item.identifications.identification2.issuer, dom));
+  });
+
+  test("should get correct identification 2 value from XML", () => {
+    expect(identification2.value._text).toBe(select(xpath.items.item.identifications.identification2.value, dom));
+  });
+
+  test("should get correct identification 2 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification2.name.content, dom);
+    expect(toTextArr(identification2.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 3 issuer from XML", () => {
+    expect(identification3.issuer._text).toBe(select(xpath.items.item.identifications.identification3.issuer, dom));
+  });
+
+  test("should get correct identification 3 value from XML", () => {
+    expect(identification3.value._text).toBe(select(xpath.items.item.identifications.identification3.value, dom));
+  });
+
+  test("should get correct identification 3 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification3.name.content, dom);
+    expect(toTextArr(identification3.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..583b3f8071a2067f9806c3dc4c75991c17cb19a4
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
@@ -0,0 +1,56 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { RespPersonType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:respPersons";
+const xpath = {
+  respPersons: {
+    respPerson1: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[1]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+      mainSigner: `string(${base}/dcc:respPerson[1]/dcc:mainSigner)`,
+    },
+    respPerson2: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[2]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: RespPersonType", () => {
+  let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
+    respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
+  });
+
+  test("should get correct responsible person 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson1.person.name.content, dom);
+    expect(toTextArr(respPerson1.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct responsible person 1 main signer flag from XML", () => {
+    expect(respPerson1.mainSigner._text).toBe(select(xpath.respPersons.respPerson1.mainSigner, dom));
+  });
+
+  test("should get correct responsible person 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson2.person.name.content, dom);
+    expect(toTextArr(respPerson2.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb02695dd288895cee0fbd635b1a7552fd9de7e2
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
@@ -0,0 +1,39 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { SoftwareListType, DCCDocument, SoftwareType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:dccSoftware/dcc:software";
+const xpath = {
+  software: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    release: `string(${base}/dcc:release)`,
+    _id: `${base}/@id`,
+    _refType: `${base}/@refType`,
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: DccSoftwareType", () => {
+  let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
+    software = dccSoftware.software[0];
+  });
+
+  test("should get correct software name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.software.name.content, dom);
+    expect(toTextArr(software.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct software release version of software from XML", () => {
+    expect(software.release._text).toBe(select(xpath.software.release, dom));
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0c5ae363f8a457ac8c3e210f06de25d667391e85
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
@@ -0,0 +1,213 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { StatementMetaDataType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:statements";
+const xpath = {
+  statements: {
+    statement1: {
+      norm: `string(${base}/dcc:statement[1]/dcc:norm)`,
+      reference: `string(${base}/dcc:statement[1]/dcc:reference)`,
+      declaration: {
+        content: `${base}/dcc:statement[1]/dcc:declaration/dcc:content`,
+      },
+      refType: `string(${base}/dcc:statement[1]/@refType)`,
+    },
+    statement2: {
+      declaration: {
+        content: `${base}/dcc:statement[2]/dcc:declaration/dcc:content`,
+      },
+      data: {
+        quantity1: {
+          name: {
+            content: `${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+          },
+          si_real: {
+            si_value: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+            si_unit: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+          },
+        },
+        quantity2: {
+          name: {
+            content: `${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+          },
+          si_real: {
+            si_value: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+            si_unit: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+          },
+        },
+      },
+      refType: `string(${base}/dcc:statement[2]/@refType)`,
+    },
+    statement3: {
+      declaration: {
+        content: `${base}/dcc:statement[3]/dcc:declaration/dcc:content`,
+      },
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[3]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:email)`,
+        location: {
+          city: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      conformity: `string(${base}/dcc:statement[3]/dcc:conformity)`,
+      refType: `string(${base}/dcc:statement[3]/@refType)`,
+    },
+    statement4: {
+      declaration: {
+        content: `${base}/dcc:statement[4]/dcc:declaration/dcc:content`,
+      },
+      date: `string(${base}/dcc:statement[4]/dcc:date)`,
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[3]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:email)`,
+        location: {
+          city: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      refType: `string(${base}/dcc:statement[4]/@refType)`,
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: StatementMetaDataType", () => {
+  let dcc: DCCDocument, statement1, statement2, statement3, statement4: StatementMetaDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
+    statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
+    statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
+    statement4 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[3];
+  });
+
+  test("should get correct statement 1 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement1.declaration.content, dom);
+    expect(toTextArr(statement1.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 1 norm model from XML", () => {
+    expect(statement1.norm[0]._text).toBe(select(xpath.statements.statement1.norm, dom));
+  });
+
+  test("should get correct statement 1 reference from XML", () => {
+    expect(statement1.reference[0]._text).toBe(select(xpath.statements.statement1.reference, dom));
+  });
+
+  test("should get correct statement 2 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.declaration.content, dom);
+    expect(toTextArr(statement2.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.data.quantity1.name.content, dom);
+    expect(toTextArr(statement2.data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 1 si:value from XML", () => {
+    expect(statement2.data.quantity[0].real.value._text).toBe(select(xpath.statements.statement2.data.quantity1.si_real.si_value, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:unit from XML", () => {
+    expect(statement2.data.quantity[0].real.unit._text).toBe(select(xpath.statements.statement2.data.quantity1.si_real.si_unit, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.data.quantity2.name.content, dom);
+    expect(toTextArr(statement2.data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:value from XML", () => {
+    expect(statement2.data.quantity[1].real.value._text).toBe(select(xpath.statements.statement2.data.quantity2.si_real.si_value, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:unit from XML", () => {
+    expect(statement2.data.quantity[1].real.unit._text).toBe(select(xpath.statements.statement2.data.quantity2.si_real.si_unit, dom));
+  });
+
+  test("should get correct statement 2 refType from XML", () => {
+    expect(statement2._attr.refType).toBe(select(xpath.statements.statement2.refType, dom));
+  });
+
+  test("should get correct statement 3 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement3.declaration.content, dom);
+    expect(toTextArr(statement3.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 3 responsible authority name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement3.respAuthority.name.content, dom);
+    expect(toTextArr(statement3.respAuthority.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* responsible authority 3 */
+  test("should get correct statement 3 responsible authority email from XML", () => {
+    expect(statement3.respAuthority.eMail._text).toBe(select(xpath.statements.statement3.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 3 responsible authority location city from XML", () => {
+    expect(statement3.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 3 responsible authority location country code from XML", () => {
+    expect(statement3.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 3 responsible authority location post code from XML", () => {
+    expect(statement3.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 3 conformity from XML", () => {
+    expect(statement3.conformity._text).toBe(select(xpath.statements.statement3.conformity, dom));
+  });
+
+  test("should get correct statement 3 refType from XML", () => {
+    expect(statement3._attr.refType).toBe(select(xpath.statements.statement3.refType, dom));
+  });
+
+  test("should get correct statement 4 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement4.declaration.content, dom);
+    expect(toTextArr(statement4.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 4 date from XML", () => {
+    expect(statement4.date._text).toBe(select(xpath.statements.statement4.date, dom));
+  });
+
+  /* responsible authority 4 */
+  test("should get correct statement 4 responsible authority email from XML", () => {
+    expect(statement4.respAuthority.eMail._text).toBe(select(xpath.statements.statement4.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 4 responsible authority location city from XML", () => {
+    expect(statement4.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 4 responsible authority location country code from XML", () => {
+    expect(statement4.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 4 responsible authority location post code from XML", () => {
+    expect(statement4.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 4 refType from XML", () => {
+    expect(statement4._attr.refType).toBe(select(xpath.statements.statement4.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..110f0961f44989f54d8e5fb07957bcf1abafb262
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
@@ -0,0 +1,21 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select } from "../../util";
+
+const VERSION_XPATH = "string(/dcc:digitalCalibrationCertificate/@schemaVersion)";
+
+describe("GP_DCC_Temperature_Typical: DigitalCalibrationCertificateType", () => {
+  let xml, dcc, dom;
+
+  beforeEach(() => {
+    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+  });
+
+  test("should get correct schemaVersion from XML", () => {
+    const expectedVersion = select(VERSION_XPATH, dom);
+    expect(dcc.digitalCalibrationCertificate._attr.schemaVersion).toBe(expectedVersion);
+  });
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..436f8d3cfdb896d88cf1d725aca46f9d1c9830ac
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -0,0 +1,249 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, InfluenceConditionListType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:influenceConditions";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      influenceConditions: {
+        influenceCondition1: {
+          name: {
+            content: `${base}/dcc:influenceCondition[1]/dcc:name/dcc:content`,
+          },
+          data: {
+            quantity: {
+              name: {
+                content: `${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[1]//@refType)`,
+        },
+        influenceCondition2: {
+          name: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='en']`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[2]//@refType)`,
+        },
+        influenceCondition3: {
+          name: {
+            content: `${base}/dcc:influenceCondition[3]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[3]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:influenceCondition[3]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:influenceCondition[3]/dcc:description/dcc:content[@lang='en']`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[3]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: InfluenceConditionListType", () => {
+  let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
+  });
+
+  test("should get correct influence condition 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 quantity 1 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 quantity 1 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..856134e3b20e1097515536d9e15bd1b5bbc5ea23
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -0,0 +1,58 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, MeasuringEquipmentType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:measuringEquipments/dcc:measuringEquipment[1]";
+const xpath = {
+  measuringEquipments: {
+    measuringEquipment: {
+      name: {
+        content: `${base}/dcc:name/dcc:content`,
+      },
+      identifications: {
+        identification: {
+          issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        },
+      },
+      refType: `string(${base}//@refType)`,
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: MeasuringEquipmentType", () => {
+  let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measuringEquipments.measuringEquipment.name.content, dom);
+    expect(toTextArr(measuringEquipment.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct measuring equipment 1 identification issuer from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].issuer._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.issuer, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 identification value from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].value._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.value, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 refType from XML", () => {
+    expect(measuringEquipment._attr.refType).toBe(select(xpath.measuringEquipments.measuringEquipment.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..892a1f3a67ceb943ac5b7c326d960982e48efa37
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
@@ -0,0 +1,35 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, MeasurementResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      name: {
+        content: `${base}/dcc:measurementResult[1]/dcc:name/dcc:content`,
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: MeasurementResultType", () => {
+  let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.name.content, dom);
+    expect(toTextArr(measurementResult.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9efe9ae6ca8da0e0dade5628f0a2cc6619c206bd
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
@@ -0,0 +1,302 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, ResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:results";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      results: {
+        result: {
+          name: {
+            content: `${base}/dcc:result[1]/dcc:name/dcc:content`,
+          },
+          data: {
+            list: {
+              quantity1: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                measurementMetaData: {
+                  metaData: {
+                    declaration: {
+                      content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:declaration/dcc:content`,
+                    },
+                    data: {
+                      quantity: {
+                        si_hybrid: {
+                          si_realListXMLList1: {
+                            si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                            si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                          },
+                          si_realListXMLList2: {
+                            si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                            si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                          },
+                        },
+                      },
+                    },
+                    refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData//@refType)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]//@refType)`,
+              },
+              quantity2: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]//@refType)`,
+              },
+              quantity3: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:name/dcc:content`,
+                },
+                si_realListXMLList: {
+                  si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:valueXMLList)`,
+                  si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:unitXMLList)`,
+                  si_expandedUncXMLList: {
+                    si_uncertaintyXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:uncertaintyXMLList)`,
+                    si_coverageFactorXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageFactorXMLList)`,
+                    si_coverageProbabilityXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageProbabilityXMLList)`,
+                    si_distributionXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:distributionXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/@refType)`,
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:result[1]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: ResultType", () => {
+  let dcc: DCCDocument, result: ResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
+  });
+
+  test("should get correct result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.name.content, dom);
+    expect(toTextArr(result.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:unitXMLList 2: from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.declaration.content, dom)
+    );
+    expect(toTextArr(result.data.list[0].quantity[0].measurementMetaData.metaData[0].declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.data.quantity.si_hybrid.si_realListXMLList1
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.data.quantity.si_hybrid.si_realListXMLList1
+          .si_unitXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.data.quantity.si_hybrid.si_realListXMLList2
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:unitXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 2 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:unitXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[2].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 3 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.uncertaintyXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_uncertaintyXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty coverage factor list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageFactorXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageFactorXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty coverage probability list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageProbabilityXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageProbabilityXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty distribution list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.distributionXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_distributionXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result refType from XML", () => {
+    expect(result._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.refType, dom));
+  });
+
+  test("should get correct result data list refType from XML", () => {
+    expect(result.data.list[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.list.refType, dom));
+  });
+
+  test("should get correct result quantity 1 refType from XML", () => {
+    expect(result.data.list[0].quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data refType from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 refType from XML", () => {
+    expect(result.data.list[0].quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 refType from XML", () => {
+    expect(result.data.list[0].quantity[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4738344ed87df3ccfc460c1b397ced4835c73c41
--- /dev/null
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -0,0 +1,81 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_Typical.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, UsedMethodListType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      usedMethods: {
+        usedMethod1: {
+          name: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:description/dcc:content[@lang='en']`,
+          },
+          norm: `string(${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:norm[1])`,
+          refType: `string(${base}/dcc:usedMethods/dcc:usedMethod[1]//@refType)`,
+        },
+        usedMethod2: {
+          name: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[2]/dcc:name/dcc:content`,
+          },
+          norm: `string(${base}/dcc:usedMethods/dcc:usedMethod[2]/dcc:norm[1])`,
+          refType: `string(${base}/dcc:usedMethods/dcc:usedMethod[2]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_DCC_Temperature_Typical: UsedMethodListType", () => {
+  let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
+  });
+
+  test("should get correct used method 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.name.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 1 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.description.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[0].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 1 norm from XML", () => {
+    expect(usedMethods.usedMethod[0].norm[0]._text).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.norm, dom));
+  });
+
+  test("should get correct used method 1 refType from XML", () => {
+    expect(usedMethods.usedMethod[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.refType, dom));
+  });
+
+  test("should get correct used method 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod2.name.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 2 norm from XML", () => {
+    expect(usedMethods.usedMethod[1].norm[0]._text).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod2.norm, dom));
+  });
+
+  test("should get correct used method 2 refType from XML", () => {
+    expect(usedMethods.usedMethod[1]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod2.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9372426d6d5fd995917d6dbcadb0c6976d5e256f
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
@@ -0,0 +1,84 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { CalibrationLaboratoryType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:calibrationLaboratory/dcc:contact";
+const xpath = {
+  name: `string(${base}/dcc:name/dcc:content)`,
+  eMail: `string(${base}/dcc:eMail)`,
+  phone: `string(${base}/dcc:phone)`,
+  fax: `string(${base}/dcc:fax)`,
+  location: {
+    city: `${base}/dcc:location/dcc:city`,
+    countryCode: `${base}/dcc:location/dcc:countryCode`,
+    postCode: `${base}/dcc:location/dcc:postCode`,
+    street: `${base}/dcc:location/dcc:street`,
+    streetNo: `${base}/dcc:location/dcc:streetNo`,
+    further: `${base}/dcc:location/dcc:further/dcc:content`,
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: CalibrationLaboratoryType", () => {
+  let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
+  });
+
+  test("should get correct name from XML", () => {
+    expect(calibrationLaboratory.contact.name.content[0]._text).toBe(select(xpath.name, dom));
+  });
+
+  test("should get correct eMail from XML", () => {
+    expect(calibrationLaboratory.contact.eMail._text).toBe(select(xpath.eMail, dom));
+  });
+
+  test("should get correct phone from XML", () => {
+    expect(calibrationLaboratory.contact.phone._text).toBe(select(xpath.phone, dom));
+  });
+
+  test("should get correct fax from XML", () => {
+    expect(calibrationLaboratory.contact.fax._text).toBe(select(xpath.fax, dom));
+  });
+
+  test("should get correct city from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.city, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.city)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct countryCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.countryCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.countryCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct postCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.postCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.postCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct street from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.street, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.street)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct streetNo from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.streetNo, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.streetNo)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct further element from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.further, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.further[0].content)).toEqual(toTextContentArr(expected));
+  });
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..96820174d4318e88c31621d8bb8620f963db350c
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
@@ -0,0 +1,128 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import * as fc from "fast-check";
+import { indexOf, select, toTextArr, toTextContentArr } from "../../util";
+import { CoreDataType, DCCDocument, DCCXMLElement } from "../../../src";
+import { string_ISO639_1 } from "../../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:coreData";
+const xpath = {
+  coreData: {
+    countryCodeISO3166_1: `string(${base}/dcc:countryCodeISO3166_1)`,
+    usedLangCodeISO639_1: `${base}/dcc:usedLangCodeISO639_1`,
+    mandatoryLangCodeISO639_1: `${base}/dcc:mandatoryLangCodeISO639_1`,
+    uniqueIdentifier: `string(${base}/dcc:uniqueIdentifier)`,
+    identifications: {
+      identification: {
+        issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+        value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        name: {
+          content: `${base}/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+        },
+      },
+    },
+    receiptData: `string(${base}/dcc:receiptDate)`,
+    beginPerformanceDate: `string(${base}/dcc:beginPerformanceDate)`,
+    endPerformanceDate: `string(${base}/dcc:endPerformanceDate)`,
+    performanceLocation: `string(${base}/dcc:performanceLocation)`,
+    issueDate: `string(${base}/dcc:issueDate)`,
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: CoreDataType", () => {
+  let dcc: DCCDocument, coreData: CoreDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
+  });
+
+  test("should get correct countryCodeISO3166_1 from XML", () => {
+    expect(coreData.countryCodeISO3166_1._text).toBe(select(xpath.coreData.countryCodeISO3166_1, dom));
+  });
+
+  test("should get correct usedLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.usedLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct mandatoryLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.mandatoryLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.mandatoryLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct unique identifier from XML", () => {
+    expect(coreData.uniqueIdentifier._text).toBe(select(xpath.coreData.uniqueIdentifier, dom));
+  });
+
+  test("should get correct identification issuer from XML", () => {
+    expect(coreData.identifications.identification[0].issuer._text).toBe(select(xpath.coreData.identifications.identification.issuer, dom));
+  });
+
+  test("should get correct identification value from XML", () => {
+    expect(coreData.identifications.identification[0].value._text).toBe(select(xpath.coreData.identifications.identification.value, dom));
+  });
+
+  test("should get correct identification name content from XML", () => {
+    const expected = <Element[]>select(xpath.coreData.identifications.identification.name.content, dom);
+    expect(toTextArr(coreData.identifications.identification[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct receipt date from XML", () => {
+    expect(coreData.receiptDate._text).toBe(select(xpath.coreData.receiptData, dom));
+  });
+
+  test("should get correct begin performance date from XML", () => {
+    expect(coreData.beginPerformanceDate._text).toBe(select(xpath.coreData.beginPerformanceDate, dom));
+  });
+
+  test("should get correct end performance date from XML", () => {
+    expect(coreData.endPerformanceDate._text).toBe(select(xpath.coreData.endPerformanceDate, dom));
+  });
+
+  test("should get correct performance location from XML", () => {
+    expect(coreData.performanceLocation._text).toBe(select(xpath.coreData.performanceLocation, dom));
+  });
+
+  test("should get correct issue date from XML", () => {
+    expect(coreData.issueDate._text).toBe(select(xpath.coreData.issueDate, dom));
+  });
+
+  /* test for setters */
+  test("should set usedLangCodeISO639_1 correctly", () => {
+    fc.assert(
+      fc.property(string_ISO639_1(), (str) => {
+        // add new element to array
+        coreData.usedLangCodeISO639_1.push(new DCCXMLElement({ _text: str }));
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).toContain(str);
+        expect(toTextContentArr(actual)).toContain(str);
+      }),
+    );
+  });
+
+  test("should delete usedLangCodeISO639_1 correctly", () => {
+    const selection = toTextContentArr(<Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom));
+    fc.assert(
+      fc.property(fc.constantFrom(...selection), (str) => {
+        // get index and remove element from array
+        const index = indexOf(coreData.usedLangCodeISO639_1, str);
+        coreData.usedLangCodeISO639_1.splice(index, 1);
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).not.toContain(str);
+        expect(toTextContentArr(actual)).not.toContain(str);
+      }),
+    );
+  });
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a11d2d102f999838bd989be315faea50af1efe2f
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
@@ -0,0 +1,70 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ContactType, DCCDocument, LocationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:customer";
+const xpath = {
+  customer: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    email: `string(${base}/dcc:eMail)`,
+    location: {
+      city: `${base}/dcc:location/dcc:city[1]`,
+      countryCode: `${base}/dcc:location/dcc:countryCode[1]`,
+      postCode: `${base}/dcc:location/dcc:postCode[1]`,
+      further: `${base}/dcc:location/dcc:further[1]/dcc:content`,
+    },
+    descriptionData: `${base}/dcc:descriptionData`,
+    _id: `${base}/@id`,
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: ContactType", () => {
+  let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
+    location = customer.location; /* TODO: check iff this variable is used anywhere */
+  });
+
+  test("should get correct customer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.customer.name.content, dom);
+    expect(toTextArr(customer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct customer email address from XML", () => {
+    expect(customer.eMail._text).toBe(select(xpath.customer.email, dom));
+  });
+
+  test("should get correct customer location city from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.city, dom);
+    expect(customer.location.city[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location county code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.countryCode, dom);
+    expect(customer.location.countryCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location post code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.postCode, dom);
+    expect(customer.location.postCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location further from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.further, dom);
+
+    for (let i = 0; i < expected.length; i++) {
+      expect(customer.location.further[0].content[i]._text).toBe(expected[i].textContent);
+    }
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..062bf5b581524aaea87924b802897613ecf1482b
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
@@ -0,0 +1,144 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ItemType, DCCDocument, IdentificationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:items";
+const xpath = {
+  items: {
+    item: {
+      name: {
+        content: `${base}/dcc:item[1]/dcc:name/dcc:content`,
+      },
+      manufacturer: {
+        name: {
+          content: `${base}/dcc:item[1]/dcc:manufacturer/dcc:name/dcc:content`,
+        },
+      },
+      model: `string(${base}/dcc:item[1]/dcc:model)`,
+      identifications: {
+        identification1: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+          },
+        },
+        identification2: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[2]/dcc:name/dcc:content`,
+          },
+        },
+        identification3: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[3]/dcc:name/dcc:content`,
+          },
+        },
+      },
+      itemQuantities: {
+        itemQuantity: {
+          name: {
+            content: `${base}/dcc:item[1]/dcc:itemQuantities/dcc:itemQuantity[1]/dcc:name/dcc:content`,
+          },
+          si_real: {
+            si_value: `string(${base}/dcc:item[1]/dcc:itemQuantities/dcc:itemQuantity[1]/si:real/si:value)`,
+            si_unit: `string(${base}/dcc:item[1]/dcc:itemQuantities/dcc:itemQuantity[1]/si:real/si:unit)`,
+          },
+        },
+      },
+      refType: `string(${base}/dcc:item[1]//@refType)`,
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: ItemType", () => {
+  let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
+    identification1 = item.identifications.identification[0];
+    identification2 = item.identifications.identification[1];
+    identification3 = item.identifications.identification[2];
+  });
+
+  test("should get correct item name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.name.content, dom);
+    expect(toTextArr(item.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item manufacturer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.manufacturer.name.content, dom);
+    expect(toTextArr(item.manufacturer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item model from XML", () => {
+    expect(item.model._text).toBe(select(xpath.items.item.model, dom));
+  });
+
+  test("should get correct identification 1 issuer from XML", () => {
+    expect(identification1.issuer._text).toBe(select(xpath.items.item.identifications.identification1.issuer, dom));
+  });
+
+  test("should get correct identification 1 value from XML", () => {
+    expect(identification1.value._text).toBe(select(xpath.items.item.identifications.identification1.value, dom));
+  });
+
+  test("should get correct identification 1 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification1.name.content, dom);
+    expect(toTextArr(identification1.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 2 issuer from XML", () => {
+    expect(identification2.issuer._text).toBe(select(xpath.items.item.identifications.identification2.issuer, dom));
+  });
+
+  test("should get correct identification 2 value from XML", () => {
+    expect(identification2.value._text).toBe(select(xpath.items.item.identifications.identification2.value, dom));
+  });
+
+  test("should get correct identification 2 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification2.name.content, dom);
+    expect(toTextArr(identification2.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification 3 issuer from XML", () => {
+    expect(identification3.issuer._text).toBe(select(xpath.items.item.identifications.identification3.issuer, dom));
+  });
+
+  test("should get correct identification 3 value from XML", () => {
+    expect(identification3.value._text).toBe(select(xpath.items.item.identifications.identification3.value, dom));
+  });
+
+  test("should get correct identification 3 name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.identifications.identification3.name.content, dom);
+    expect(toTextArr(identification3.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item quantity name content from XML", () => {
+    const expected = <Element[]>select(xpath.items.item.itemQuantities.itemQuantity.name.content, dom);
+    expect(toTextArr(item.itemQuantities.itemQuantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item quantity real value from XML", () => {
+    expect(item.itemQuantities.itemQuantity[0].real.value._text).toBe(select(xpath.items.item.itemQuantities.itemQuantity.si_real.si_value, dom));
+  });
+
+  test("should get correct item quantity real unit from XML", () => {
+    expect(item.itemQuantities.itemQuantity[0].real.unit._text).toBe(select(xpath.items.item.itemQuantities.itemQuantity.si_real.si_unit, dom));
+  });
+
+  test("should get correct item refType from XML", () => {
+    expect(item._attr.refType).toBe(select(xpath.items.item.refType, dom));
+  });
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0400f0b61f92f09bb3700f637bd22bd8d1517a72
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
@@ -0,0 +1,72 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, RefTypeDefinitionType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:refTypeDefinitions/dcc:refTypeDefinition[1]";
+const xpath = {
+  name: {
+    content: `${base}/dcc:name/dcc:content`,
+  },
+  description: {
+    name: {
+      content: `${base}/dcc:description/dcc:name/dcc:content`,
+    },
+    content: `${base}/dcc:description/dcc:content`,
+  },
+  namespace: `string(${base}/dcc:namespace)`,
+  link: `string(${base}/dcc:link)`,
+  release: `string(${base}/dcc:release)`,
+  value: `string(${base}/dcc:value)`,
+  procedure: `string(${base}/dcc:procedure)`,
+};
+
+describe("GP_Temperature_Complete_DCC: RefTypeDefinitionType", () => {
+  let dcc: DCCDocument, refTypeDefinition: RefTypeDefinitionType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    refTypeDefinition = dcc.digitalCalibrationCertificate.administrativeData.refTypeDefinitions.refTypeDefinition[0];
+  });
+
+  test("should get correct name from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.name.content, dom);
+    expect(toTextArr(refTypeDefinition.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct description name from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.description.name.content, dom);
+    expect(toTextArr(refTypeDefinition.description.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.description.content, dom);
+    expect(toTextArr(refTypeDefinition.description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct namespace from XML", () => {
+    expect(refTypeDefinition.namespace._text).toBe(select(xpath.namespace, dom));
+  });
+
+  test("should get correct link from XML", () => {
+    expect(refTypeDefinition.link._text).toBe(select(xpath.link, dom));
+  });
+
+  test("should get correct release from XML", () => {
+    expect(refTypeDefinition.release._text).toBe(select(xpath.release, dom));
+  });
+
+  test("should get correct value from XML", () => {
+    expect(refTypeDefinition.value._text).toBe(select(xpath.value, dom));
+  });
+
+  test("should get correct procedure from XML", () => {
+    expect(refTypeDefinition.procedure._text).toBe(select(xpath.procedure, dom));
+  });
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..768e9e21565b660f1579d6687409202da8dd95a2
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
@@ -0,0 +1,56 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { RespPersonType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:respPersons";
+const xpath = {
+  respPersons: {
+    respPerson1: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[1]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+      mainSigner: `string(${base}/dcc:respPerson[1]/dcc:mainSigner)`,
+    },
+    respPerson2: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[2]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: RespPersonType", () => {
+  let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
+    respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
+  });
+
+  test("should get correct responsible person 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson1.person.name.content, dom);
+    expect(toTextArr(respPerson1.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct responsible person 1 main signer flag from XML", () => {
+    expect(respPerson1.mainSigner._text).toBe(select(xpath.respPersons.respPerson1.mainSigner, dom));
+  });
+
+  test("should get correct responsible person 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson2.person.name.content, dom);
+    expect(toTextArr(respPerson2.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..39aadae996a290a4bc8808f129415a6b1582ce20
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
@@ -0,0 +1,60 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { SoftwareListType, DCCDocument, SoftwareType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:dccSoftware/dcc:software";
+const xpath = {
+  software: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    release: `string(${base}/dcc:release)`,
+    type: `string(${base}/dcc:type)`,
+    description: {
+      name: {
+        content: `${base}/dcc:description/dcc:name/dcc:content`,
+      },
+      content: `${base}/dcc:description/dcc:content`,
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: DccSoftwareType", () => {
+  let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
+    software = dccSoftware.software[0];
+  });
+
+  test("should get correct software name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.software.name.content, dom);
+    expect(toTextArr(software.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct software release version of software from XML", () => {
+    expect(software.release._text).toBe(select(xpath.software.release, dom));
+  });
+
+  test("should get correct software type of software from XML", () => {
+    expect(software.type._text).toBe(select(xpath.software.type, dom));
+  });
+
+  test("should get correct description name content of software from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.software.description.name.content, dom);
+    expect(toTextArr(software.description.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct description content of software from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.software.description.content, dom);
+    expect(toTextArr(software.description.content)).toEqual(toTextContentArr(expected));
+  });
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..10288f87f5d4ba25547015759dead2a6582e0828
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
@@ -0,0 +1,127 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { StatementMetaDataType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:statements";
+const xpath = {
+  statements: {
+    statement1: {
+      declaration: {
+        content: `${base}/dcc:statement[1]/dcc:declaration/dcc:content`,
+      },
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[1]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:eMail)`,
+        location: {
+          city: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[1]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      conformity: `string(${base}/dcc:statement[1]/dcc:conformity)`,
+      refType: `string(${base}/dcc:statement[1]/@refType)`,
+    },
+    statement2: {
+      declaration: {
+        content: `${base}/dcc:statement[2]/dcc:declaration/dcc:content`,
+      },
+      date: `string(${base}/dcc:statement[2]/dcc:date)`,
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[2]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:eMail)`,
+        location: {
+          city: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[2]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      refType: `string(${base}/dcc:statement[2]/@refType)`,
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: StatementMetaDataType", () => {
+  let dcc: DCCDocument, statement1, statement2: StatementMetaDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
+    statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
+  });
+
+  test("should get correct statement 1 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement1.declaration.content, dom);
+    expect(toTextArr(statement1.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* responsible authority 1 */
+  test("should get correct statement 1 responsible authority name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement1.respAuthority.name.content, dom);
+    expect(toTextArr(statement1.respAuthority.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 1 responsible authority email from XML", () => {
+    expect(statement1.respAuthority.eMail._text).toBe(select(xpath.statements.statement1.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 1 responsible authority location city from XML", () => {
+    expect(statement1.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement1.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 1 responsible authority location country code from XML", () => {
+    expect(statement1.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement1.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 1 responsible authority location post code from XML", () => {
+    expect(statement1.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement1.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 1 conformity from XML", () => {
+    expect(statement1.conformity._text).toBe(select(xpath.statements.statement1.conformity, dom));
+  });
+
+  test("should get correct statement 2 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.declaration.content, dom);
+    expect(toTextArr(statement2.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 refType from XML", () => {
+    expect(statement2.date._text).toBe(select(xpath.statements.statement2.date, dom));
+  });
+
+  /* responsible authority 2 */
+  test("should get correct statement 2 responsible authority name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.respAuthority.name.content, dom);
+    expect(toTextArr(statement2.respAuthority.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 responsible authority email from XML", () => {
+    expect(statement2.respAuthority.eMail._text).toBe(select(xpath.statements.statement2.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 2 responsible authority location city from XML", () => {
+    expect(statement2.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement2.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 2 responsible authority location country code from XML", () => {
+    expect(statement2.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement2.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 2 responsible authority location post code from XML", () => {
+    expect(statement2.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement2.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 2 refType from XML", () => {
+    expect(statement2._attr.refType).toBe(select(xpath.statements.statement2.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae1ad14af0e270b06e5990dba58fbc17ccc6b2ad
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
@@ -0,0 +1,21 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select } from "../../util";
+
+const VERSION_XPATH = "string(/dcc:digitalCalibrationCertificate/@schemaVersion)";
+
+describe("GP_Temperature_Complete_DCC: DigitalCalibrationCertificateType", () => {
+  let xml, dcc, dom;
+
+  beforeEach(() => {
+    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+  });
+
+  test("should get correct schemaVersion from XML", () => {
+    const expectedVersion = select(VERSION_XPATH, dom);
+    expect(dcc.digitalCalibrationCertificate._attr.schemaVersion).toBe(expectedVersion);
+  });
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d8fbacaa9e123ed18531c21b2875edf374d55c0
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -0,0 +1,218 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, InfluenceConditionListType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:influenceConditions";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      influenceConditions: {
+        influenceCondition1: {
+          name: {
+            content: `${base}/dcc:influenceCondition[1]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[1]/dcc:description/dcc:content`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[1]//@refType)`,
+        },
+        influenceCondition2: {
+          name: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='en']`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[2]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: InfluenceConditionListType", () => {
+  let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
+  });
+
+  test("should get correct influence condition 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..86b8a4d555fd0299110ce937e50dbd45f22b317e
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -0,0 +1,58 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, MeasuringEquipmentType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:measuringEquipments/dcc:measuringEquipment[1]";
+const xpath = {
+  measuringEquipments: {
+    measuringEquipment: {
+      name: {
+        content: `${base}/dcc:name/dcc:content`,
+      },
+      identifications: {
+        identification: {
+          issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        },
+      },
+      refType: `string(${base}//@refType)`,
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: MeasuringEquipmentType", () => {
+  let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measuringEquipments.measuringEquipment.name.content, dom);
+    expect(toTextArr(measuringEquipment.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct measuring equipment 1 identification issuer from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].issuer._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.issuer, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 identification value from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].value._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.value, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 refType from XML", () => {
+    expect(measuringEquipment._attr.refType).toBe(select(xpath.measuringEquipments.measuringEquipment.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f5f95f78220eb39a42a1fcbefec5798fe342459e
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
@@ -0,0 +1,35 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, MeasurementResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      name: {
+        content: `${base}/dcc:measurementResult[1]/dcc:name/dcc:content`,
+      },
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: MeasurementResultType", () => {
+  let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.name.content, dom);
+    expect(toTextArr(measurementResult.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b01f474af886f32a45004757e6c89e035f3e53d
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
@@ -0,0 +1,737 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, ResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:results";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      results: {
+        result: {
+          name: {
+            content: `${base}/dcc:result[1]/dcc:name/dcc:content`,
+          },
+          data: {
+            list: {
+              quantity1: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]//@refType)`,
+              },
+              quantity2: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]//@refType)`,
+              },
+              quantity3: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:name/dcc:content`,
+                },
+                si_realListXMLList: {
+                  si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:valueXMLList)`,
+                  si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:unitXMLList)`,
+                  si_expandedUncXMLList: {
+                    si_uncertaintyXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:uncertaintyXMLList)`,
+                    si_coverageFactorXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageFactorXMLList)`,
+                    si_coverageProbabilityXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageProbabilityXMLList)`,
+                    si_distributionXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:distributionXMLList)`,
+                  },
+                },
+                measurementMetaData: {
+                  metaData: {
+                    declaration: {
+                      name: {
+                        content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData[1]/dcc:declaration/dcc:name/dcc:content`,
+                      },
+                    },
+                    conformityXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:conformityXMLList)`,
+                    data: {
+                      quantity1: {
+                        si_realListXMLList: {
+                          si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:realListXMLList/si:valueXMLList)`,
+                          si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:realListXMLList/si:unitXMLList)`,
+                        },
+                        refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]//@refType)`,
+                      },
+                      quantity2: {
+                        si_realListXMLList: {
+                          si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[2]/si:realListXMLList/si:valueXMLList)`,
+                          si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[2]/si:realListXMLList/si:unitXMLList)`,
+                        },
+                        refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[2]//@refType)`,
+                      },
+                    },
+                    refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:measurementMetaData/dcc:metaData//@refType)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/@refType)`,
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list//@refType)`,
+            },
+            quantity1: {
+              noQuantity: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:quantity[1]/dcc:noQuantity/dcc:name/dcc:content`,
+                },
+                content: `${base}/dcc:result[1]/dcc:data/dcc:quantity[1]/dcc:noQuantity/dcc:content`,
+                file: {
+                  fileName: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[1]/dcc:noQuantity/dcc:file[1]/dcc:fileName)`,
+                  mimeType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[1]/dcc:noQuantity/dcc:file[1]/dcc:mimeType)`,
+                  dataBase64: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[1]/dcc:noQuantity/dcc:file[1]/dcc:dataBase64)`,
+                  refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[1]/dcc:noQuantity/dcc:file[1]//@refType)`,
+                },
+                formula: {
+                  latex: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[1]/dcc:noQuantity/dcc:formula[1]/dcc:latex)`,
+                },
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              charsXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[2]/dcc:charsXMLList)`,
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+            quantity3: {
+              si_constant: {
+                si_label: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[3]/si:constant/si:label)`,
+                si_value: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[3]/si:constant/si:value)`,
+                si_unit: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[3]/si:constant/si:unit)`,
+                si_dateTime: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[3]/si:constant/si:dateTime)`,
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[3]//@refType)`,
+            },
+            quantity4: {
+              si_real: {
+                si_label: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[4]/si:real/si:label)`,
+                si_value: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[4]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[4]/si:real/si:unit)`,
+                si_dateTime: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[4]/si:real/si:dateTime)`,
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[4]//@refType)`,
+            },
+            quantity5: {
+              si_realListXMLList: {
+                si_labelXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[5]/si:realListXMLList/si:labelXMLList)`,
+                si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[5]/si:realListXMLList/si:valueXMLList)`,
+                si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[5]/si:realListXMLList/si:unitXMLList)`,
+                si_dateTimeXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[5]/si:realListXMLList/si:dateTimeXMLList)`,
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[5]//@refType)`,
+            },
+            quantity6: {
+              si_hybrid: {
+                si_constant1: {
+                  si_label: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[1]/si:label)`,
+                  si_value: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[1]/si:value)`,
+                  si_unit: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[1]/si:unit)`,
+                  si_dateTime: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[1]/si:dateTime)`,
+                },
+                si_constant2: {
+                  si_label: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[2]/si:label)`,
+                  si_value: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[2]/si:value)`,
+                  si_unit: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[2]/si:unit)`,
+                  si_dateTime: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]/si:hybrid/si:constant[2]/si:dateTime)`,
+                },
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[6]//@refType)`,
+            },
+            quantity7: {
+              si_hybrid: {
+                si_real1: {
+                  si_label: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[1]/si:label)`,
+                  si_value: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[1]/si:value)`,
+                  si_unit: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[1]/si:unit)`,
+                  si_dateTime: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[1]/si:dateTime)`,
+                },
+                si_real2: {
+                  si_label: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[2]/si:label)`,
+                  si_value: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[2]/si:value)`,
+                  si_unit: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[2]/si:unit)`,
+                  si_dateTime: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]/si:hybrid/si:real[2]/si:dateTime)`,
+                },
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[7]//@refType)`,
+            },
+            quantity8: {
+              si_hybrid: {
+                si_realListXMLList1: {
+                  si_labelXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[1]/si:labelXMLList)`,
+                  si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                  si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  si_dateTimeXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[1]/si:dateTimeXMLList)`,
+                },
+                si_realListXMLList2: {
+                  si_labelXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[2]/si:labelXMLList)`,
+                  si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                  si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  si_dateTimeXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]/si:hybrid/si:realListXMLList[2]/si:dateTimeXMLList)`,
+                },
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:quantity[8]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:result[1]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: ResultType", () => {
+  let dcc: DCCDocument, result: ResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
+  });
+
+  test("should get correct result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.name.content, dom);
+    expect(toTextArr(result.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result list quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result list quantity 1 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 1 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 1 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 1 hybrid si:unitXMLList 2: from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result list quantity 2 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 2 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 2 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 2 hybrid si:unitXMLList 2: from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 3 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[2].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result list quantity 3 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 3 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 3 uncertainty list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.uncertaintyXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_uncertaintyXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 3 uncertainty coverage factor list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageFactorXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageFactorXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result list quantity 3 uncertainty coverage probability list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageProbabilityXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageProbabilityXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result list quantity 3 uncertainty distribution list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.distributionXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_distributionXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result list quantity 3 meta data declaration name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.declaration.name.content, dom)
+    );
+    expect(toTextArr(result.data.list[0].quantity[2].measurementMetaData.metaData[0].declaration.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result list quantity 3 meta data conformityXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].conformityXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.conformityXMLList, dom),
+    );
+  });
+
+  test("should get correct result list quantity 3 meta data quantity 1 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[0].realListXMLList.valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity1.si_realListXMLList
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result list quantity 3 meta data quantity 1 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[0].realListXMLList.unitXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity1.si_realListXMLList
+          .si_unitXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result list quantity 3 meta data quantity 2 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[1].realListXMLList.valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity2.si_realListXMLList
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result list quantity 3 meta data quantity 2 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[1].realListXMLList.valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity2.si_realListXMLList
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result list quantity 3 meta data quantity 2 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0].data.quantity[1].realListXMLList.unitXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.data.quantity2.si_realListXMLList
+          .si_unitXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result refType from XML", () => {
+    expect(result._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.refType, dom));
+  });
+
+  test("should get correct result data list refType from XML", () => {
+    expect(result.data.list[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.list.refType, dom));
+  });
+
+  test("should get correct result list quantity 1 refType from XML", () => {
+    expect(result.data.list[0].quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct result list quantity2 refType from XML", () => {
+    expect(result.data.list[0].quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct result list quantity3 refType from XML", () => {
+    expect(result.data.list[0].quantity[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.refType, dom),
+    );
+  });
+
+  test("should get correct result list quantity 3 meta data refType from XML", () => {
+    expect(result.data.list[0].quantity[2].measurementMetaData.metaData[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.measurementMetaData.metaData.refType, dom),
+    );
+  });
+
+  test("should get correct result list quantity 2 refType from XML", () => {
+    expect(result.data.list[0].quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct result list quantity 3 refType from XML", () => {
+    expect(result.data.list[0].quantity[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.refType, dom),
+    );
+  });
+
+  test("should get correct result no quantity name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.name.content, dom);
+    expect(toTextArr(result.data.quantity[0].noQuantity.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result no quantity content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.content, dom);
+    expect(toTextArr(result.data.quantity[0].noQuantity.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result no quantity file fileName from XML", () => {
+    expect(result.data.quantity[0].noQuantity.file[0].fileName._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.file.fileName, dom),
+    );
+  });
+
+  test("should get correct result no quantity file mimeType from XML", () => {
+    expect(result.data.quantity[0].noQuantity.file[0].mimeType._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.file.mimeType, dom),
+    );
+  });
+
+  test("should get correct result no quantity file dataBase64 from XML", () => {
+    expect(result.data.quantity[0].noQuantity.file[0].dataBase64._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.file.dataBase64, dom),
+    );
+  });
+
+  test("should get correct result no quantity file refType from XML", () => {
+    expect(result.data.quantity[0].noQuantity.file[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.file.refType, dom),
+    );
+  });
+
+  test("should get correct result no quantity formula latex from XML", () => {
+    expect(result.data.quantity[0].noQuantity.formula[0].latex._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.formula.latex, dom),
+    );
+  });
+
+  test("should get correct result no quantity file refType from XML", () => {
+    expect(result.data.quantity[0].noQuantity.file[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity1.noQuantity.file.refType, dom),
+    );
+  });
+
+  test("should get correct result charsXMLList value from XML", () => {
+    expect(result.data.quantity[1].charsXMLList._text).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity2.charsXMLList, dom));
+  });
+
+  test("should get correct result const label from XML", () => {
+    expect(result.data.quantity[2].constant.label._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity3.si_constant.si_label, dom),
+    );
+  });
+
+  test("should get correct result const value from XML", () => {
+    expect(result.data.quantity[2].constant.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity3.si_constant.si_value, dom),
+    );
+  });
+
+  test("should get correct result const unit from XML", () => {
+    expect(result.data.quantity[2].constant.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity3.si_constant.si_unit, dom),
+    );
+  });
+
+  test("should get correct result const dateTime from XML", () => {
+    expect(result.data.quantity[2].constant.dateTime._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity3.si_constant.si_dateTime, dom),
+    );
+  });
+
+  test("should get correct result real label from XML", () => {
+    expect(result.data.quantity[3].real.label._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity4.si_real.si_label, dom),
+    );
+  });
+
+  test("should get correct result real value from XML", () => {
+    expect(result.data.quantity[3].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity4.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct result real unit from XML", () => {
+    expect(result.data.quantity[3].real.unit._text).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity4.si_real.si_unit, dom));
+  });
+
+  test("should get correct result real dateTime from XML", () => {
+    expect(result.data.quantity[3].real.dateTime._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity4.si_real.si_dateTime, dom),
+    );
+  });
+
+  test("should get correct result realListXMLList label list from XML", () => {
+    expect(result.data.quantity[4].realListXMLList.labelXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity5.si_realListXMLList.si_labelXMLList, dom),
+    );
+  });
+
+  test("should get correct result realListXMLList value list from XML", () => {
+    expect(result.data.quantity[4].realListXMLList.valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity5.si_realListXMLList.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result realListXMLList unit list from XML", () => {
+    expect(result.data.quantity[4].realListXMLList.unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity5.si_realListXMLList.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result realListXMLList dateTime list from XML", () => {
+    expect(result.data.quantity[4].realListXMLList.dateTimeXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity5.si_realListXMLList.si_dateTimeXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 1 label from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[0].label._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant1.si_label, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 1 value from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[0].value._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant1.si_value, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 1 unit from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[0].unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant1.si_unit, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 1 dateTime from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[0].dateTime._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant1.si_dateTime, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 2 label from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[1].label._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant2.si_label, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 2 value from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[1].value._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant2.si_value, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 2 unit from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[1].unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant2.si_unit, dom),
+    );
+  });
+
+  test("should get correct result hybrid const 2 dateTime from XML", () => {
+    expect(result.data.quantity[5].hybrid.constant[1].dateTime._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity6.si_hybrid.si_constant2.si_dateTime, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 1 label from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[0].label._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real1.si_label, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 1 value from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[0].value._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real1.si_value, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 1 unit from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[0].unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real1.si_unit, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 1 dateTime from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[0].dateTime._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real1.si_dateTime, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 2 label from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[1].label._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real2.si_label, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 2 value from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[1].value._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real2.si_value, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 2 unit from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[1].unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real2.si_unit, dom),
+    );
+  });
+
+  test("should get correct result hybrid real 2 dateTime from XML", () => {
+    expect(result.data.quantity[6].hybrid.real[1].dateTime._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity7.si_hybrid.si_real2.si_dateTime, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 1 label from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[0].labelXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList1.si_labelXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 1 value from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 1 unit from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 1 dateTime from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[0].dateTimeXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList1.si_dateTimeXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 2 label from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[1].labelXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList2.si_labelXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 2 value from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 2 unit from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result hybrid realListXMLList 2 dateTime from XML", () => {
+    expect(result.data.quantity[7].hybrid.realListXMLList[1].dateTimeXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.quantity8.si_hybrid.si_realListXMLList2.si_dateTimeXMLList, dom),
+    );
+  });
+
+  test("should get correct result no quantity refType from XML", () => {
+    expect(result.data.quantity[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity1.refType, dom));
+  });
+
+  test("should get correct result charsXMLList refType from XML", () => {
+    expect(result.data.quantity[1]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity2.refType, dom));
+  });
+
+  test("should get correct result const refType from XML", () => {
+    expect(result.data.quantity[2]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity3.refType, dom));
+  });
+
+  test("should get correct result real refType from XML", () => {
+    expect(result.data.quantity[3]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity4.refType, dom));
+  });
+
+  test("should get correct result realListXMLList refType from XML", () => {
+    expect(result.data.quantity[4]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity5.refType, dom));
+  });
+
+  test("should get correct result hybrid const refType from XML", () => {
+    expect(result.data.quantity[5]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity6.refType, dom));
+  });
+
+  test("should get correct result hybrid real refType from XML", () => {
+    expect(result.data.quantity[6]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity7.refType, dom));
+  });
+
+  test("should get correct result hybrid realListXMLList refType from XML", () => {
+    expect(result.data.quantity[7]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.quantity8.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d16b268dda98cdd65666a4fcdcf853b2ccf385b1
--- /dev/null
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -0,0 +1,44 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, UsedMethodListType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      usedMethods: {
+        usedMethod1: {
+          name: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:name/dcc:content`,
+          },
+          refType: `string(${base}/dcc:usedMethods/dcc:usedMethod[1]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("GP_Temperature_Complete_DCC: UsedMethodListType", () => {
+  let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
+  });
+
+  test("should get correct used method 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.name.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 1 refType from XML", () => {
+    expect(usedMethods.usedMethod[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5f4974e098b7cc3e680620749119b8e80564009e
--- /dev/null
+++ b/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -0,0 +1,249 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { DCCDocument, InfluenceConditionListType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:influenceConditions";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      influenceConditions: {
+        influenceCondition1: {
+          name: {
+            content: `${base}/dcc:influenceCondition[1]/dcc:name/dcc:content`,
+          },
+          data: {
+            quantity: {
+              name: {
+                content: `${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[1]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[1]//@refType)`,
+        },
+        influenceCondition2: {
+          name: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:influenceCondition[2]/dcc:description/dcc:content[@lang='en']`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[2]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[2]//@refType)`,
+        },
+        influenceCondition3: {
+          name: {
+            content: `${base}/dcc:influenceCondition[3]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:influenceCondition[3]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:influenceCondition[3]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:influenceCondition[3]/dcc:description/dcc:content[@lang='en']`,
+          },
+          data: {
+            quantity1: {
+              name: {
+                content: `${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[1]//@refType)`,
+            },
+            quantity2: {
+              name: {
+                content: `${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+              },
+              si_real: {
+                si_value: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+                si_unit: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+              },
+              refType: `string(${base}/dcc:influenceCondition[3]/dcc:data/dcc:quantity[2]//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:influenceCondition[3]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("InfluenceConditionListType", () => {
+  let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
+  });
+
+  test("should get correct influence condition 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[0].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 1 quantity si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 quantity si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[0].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.data.quantity.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 1 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition1.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 1 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[1].data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[1].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 2 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition2.refType, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.description.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity1.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 quantity 1 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[0].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity1.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 quantity 1 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[0].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity1.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity2.name.content, dom);
+    expect(toTextArr(influenceConditions.influenceCondition[2].data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct influence condition 3 quantity 2 si:value from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[1].real.value._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity2.si_real.si_value, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 quantity 2 si:unit from XML", () => {
+    expect(influenceConditions.influenceCondition[2].data.quantity[1].real.unit._text).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.data.quantity2.si_real.si_unit, dom),
+    );
+  });
+
+  test("should get correct influence condition 3 refType from XML", () => {
+    expect(influenceConditions.influenceCondition[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.influenceConditions.influenceCondition3.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8107d84f5dc32f4465bc300425f321f8730d1b25
--- /dev/null
+++ b/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -0,0 +1,58 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { DCCDocument, MeasuringEquipmentType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:measuringEquipments/dcc:measuringEquipment[1]";
+const xpath = {
+  measuringEquipments: {
+    measuringEquipment: {
+      name: {
+        content: `${base}/dcc:name/dcc:content`,
+      },
+      identifications: {
+        identification: {
+          issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        },
+      },
+      refType: `string(${base}//@refType)`,
+    },
+  },
+};
+
+describe("MeasuringEquipmentType", () => {
+  let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measuringEquipments.measuringEquipment.name.content, dom);
+    expect(toTextArr(measuringEquipment.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct measuring equipment 1 identification issuer from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].issuer._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.issuer, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 identification value from XML", () => {
+    expect(measuringEquipment.identifications.identification[0].value._text).toBe(
+      select(xpath.measuringEquipments.measuringEquipment.identifications.identification.value, dom),
+    );
+  });
+
+  test("should get correct measuring equipment 1 refType from XML", () => {
+    expect(measuringEquipment._attr.refType).toBe(select(xpath.measuringEquipments.measuringEquipment.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1828f271221c07be3aaa1a5c79286e7055fb8a9a
--- /dev/null
+++ b/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
@@ -0,0 +1,35 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { DCCDocument, MeasurementResultType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      name: {
+        content: `${base}/dcc:measurementResult[1]/dcc:name/dcc:content`,
+      },
+    },
+  },
+};
+
+describe("MeasurementResultType", () => {
+  let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.name.content, dom);
+    expect(toTextArr(measurementResult.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..64536b72f53101592e11e8d4f14834228e45e993
--- /dev/null
+++ b/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
@@ -0,0 +1,302 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { DCCDocument, ResultType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:results";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      results: {
+        result: {
+          name: {
+            content: `${base}/dcc:result[1]/dcc:name/dcc:content`,
+          },
+          data: {
+            list: {
+              quantity1: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                measurementMetaData: {
+                  metaData: {
+                    declaration: {
+                      content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:declaration/dcc:content`,
+                    },
+                    data: {
+                      quantity: {
+                        si_hybrid: {
+                          si_realListXMLList1: {
+                            si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                            si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                          },
+                          si_realListXMLList2: {
+                            si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                            si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData/dcc:data/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                          },
+                        },
+                      },
+                    },
+                    refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:measurementMetaData/dcc:metaData//@refType)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]//@refType)`,
+              },
+              quantity2: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[2]//@refType)`,
+              },
+              quantity3: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/dcc:name/dcc:content`,
+                },
+                si_realListXMLList: {
+                  si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:valueXMLList)`,
+                  si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:unitXMLList)`,
+                  si_expandedUncXMLList: {
+                    si_uncertaintyXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:uncertaintyXMLList)`,
+                    si_coverageFactorXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageFactorXMLList)`,
+                    si_coverageProbabilityXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:coverageProbabilityXMLList)`,
+                    si_distributionXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/si:realListXMLList[1]/si:expandedUncXMLList/si:distributionXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[3]/@refType)`,
+              },
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:result[1]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("ResultType", () => {
+  let dcc: DCCDocument, result: ResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
+  });
+
+  test("should get correct result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.name.content, dom);
+    expect(toTextArr(result.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 hybrid si:unitXMLList 2: from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.declaration.content, dom)
+    );
+    expect(toTextArr(result.data.list[0].quantity[0].measurementMetaData.metaData[0].declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.data.quantity.si_hybrid.si_realListXMLList1
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.data.quantity.si_hybrid.si_realListXMLList1
+          .si_unitXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.data.quantity.si_hybrid.si_realListXMLList2
+          .si_valueXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data hybrid si:unitXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0].data.quantity[0].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 2 hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 hybrid si:unitXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[1].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.name.content, dom);
+    expect(toTextArr(result.data.list[0].quantity[2].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity 3 si:valueXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 si:unitXMLList from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.uncertaintyXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_uncertaintyXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty coverage factor list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageFactorXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageFactorXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty coverage probability list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.coverageProbabilityXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_coverageProbabilityXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result quantity 3 uncertainty distribution list from XML", () => {
+    expect(result.data.list[0].quantity[2].realListXMLList.expandedUncXMLList.distributionXMLList._text).toBe(
+      select(
+        xpath.measurementResults.measurementResult.results.result.data.list.quantity3.si_realListXMLList.si_expandedUncXMLList.si_distributionXMLList,
+        dom,
+      ),
+    );
+  });
+
+  test("should get correct result refType from XML", () => {
+    expect(result._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.refType, dom));
+  });
+
+  test("should get correct result data list refType from XML", () => {
+    expect(result.data.list[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.list.refType, dom));
+  });
+
+  test("should get correct result quantity 1 refType from XML", () => {
+    expect(result.data.list[0].quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 1 meta data refType from XML", () => {
+    expect(result.data.list[0].quantity[0].measurementMetaData.metaData[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity1.measurementMetaData.metaData.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 2 refType from XML", () => {
+    expect(result.data.list[0].quantity[1]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity2.refType, dom),
+    );
+  });
+
+  test("should get correct result quantity 3 refType from XML", () => {
+    expect(result.data.list[0].quantity[2]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity3.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..54cdf56cceaf723e030a79ae1d54a48ec65512ec
--- /dev/null
+++ b/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -0,0 +1,81 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { DCCDocument, MeasurementResultType, UsedMethodListType, UsedMethodType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      usedMethods: {
+        usedMethod1: {
+          name: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:name/dcc:content`,
+          },
+          description: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:description/dcc:content`,
+            contentDE: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:description/dcc:content[@lang='de']`,
+            contentEN: `${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:description/dcc:content[@lang='en']`,
+          },
+          norm: `string(${base}/dcc:usedMethods/dcc:usedMethod[1]/dcc:norm[1])`,
+          refType: `string(${base}/dcc:usedMethods/dcc:usedMethod[1]//@refType)`,
+        },
+        usedMethod2: {
+          name: {
+            content: `${base}/dcc:usedMethods/dcc:usedMethod[2]/dcc:name/dcc:content`,
+          },
+          norm: `string(${base}/dcc:usedMethods/dcc:usedMethod[2]/dcc:norm[1])`,
+          refType: `string(${base}/dcc:usedMethods/dcc:usedMethod[2]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("UsedMethodListType", () => {
+  let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
+  });
+
+  test("should get correct used method 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.name.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 1 description content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.description.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[0].description.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 1 norm from XML", () => {
+    expect(usedMethods.usedMethod[0].norm[0]._text).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.norm, dom));
+  });
+
+  test("should get correct used method 1 refType from XML", () => {
+    expect(usedMethods.usedMethod[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod1.refType, dom));
+  });
+
+  test("should get correct used method 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.usedMethods.usedMethod2.name.content, dom);
+    expect(toTextArr(usedMethods.usedMethod[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct used method 2 norm from XML", () => {
+    expect(usedMethods.usedMethod[1].norm[0]._text).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod2.norm, dom));
+  });
+
+  test("should get correct used method 2 refType from XML", () => {
+    expect(usedMethods.usedMethod[1]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.usedMethods.usedMethod2.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3529e3bb4a840102afa02c84f3c0b14a5eb4e18c
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
@@ -0,0 +1,34 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { CalibrationLaboratoryType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:calibrationLaboratory/dcc:contact";
+const xpath = {
+  name: `string(${base}/dcc:name/dcc:content)`,
+  location: {
+    city: `${base}/dcc:location/dcc:city`,
+  },
+};
+
+describe("Test_DCC_Minimal: CalibrationLaboratoryType", () => {
+  let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
+  });
+
+  test("should get correct name from XML", () => {
+    expect(calibrationLaboratory.contact.name.content[0]._text).toBe(select(xpath.name, dom));
+  });
+
+  test("should get correct city from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.city, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.city)).toEqual(toTextContentArr(expected));
+  });
+});
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e9ca47c8bc52429a1de605146f3103c6c69b2f2b
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
@@ -0,0 +1,116 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import * as fc from "fast-check";
+import { indexOf, select, toTextArr, toTextContentArr } from "../../util";
+import { CoreDataType, DCCDocument, DCCXMLElement } from "../../../src";
+import { string_ISO639_1 } from "../../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:coreData";
+const xpath = {
+  coreData: {
+    countryCodeISO3166_1: `string(${base}/dcc:countryCodeISO3166_1)`,
+    usedLangCodeISO639_1: `${base}/dcc:usedLangCodeISO639_1`,
+    mandatoryLangCodeISO639_1: `${base}/dcc:mandatoryLangCodeISO639_1`,
+    uniqueIdentifier: `string(${base}/dcc:uniqueIdentifier)`,
+    identifications: {
+      identification: {
+        issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+        value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        name: {
+          content: `${base}/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+        },
+      },
+    },
+    beginPerformanceDate: `string(${base}/dcc:beginPerformanceDate)`,
+    endPerformanceDate: `string(${base}/dcc:endPerformanceDate)`,
+    performanceLocation: `string(${base}/dcc:performanceLocation)`,
+  },
+};
+
+describe("Test_DCC_Minimal: CoreDataType", () => {
+  let dcc: DCCDocument, coreData: CoreDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
+  });
+
+  test("should get correct countryCodeISO3166_1 from XML", () => {
+    expect(coreData.countryCodeISO3166_1._text).toBe(select(xpath.coreData.countryCodeISO3166_1, dom));
+  });
+
+  test("should get correct usedLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.usedLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct mandatoryLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.mandatoryLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.mandatoryLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct unique identifier from XML", () => {
+    expect(coreData.uniqueIdentifier._text).toBe(select(xpath.coreData.uniqueIdentifier, dom));
+  });
+
+  test("should get correct identification issuer from XML", () => {
+    expect(coreData.identifications.identification[0].issuer._text).toBe(select(xpath.coreData.identifications.identification.issuer, dom));
+  });
+
+  test("should get correct identification value from XML", () => {
+    expect(coreData.identifications.identification[0].value._text).toBe(select(xpath.coreData.identifications.identification.value, dom));
+  });
+
+  test("should get correct identification name content from XML", () => {
+    const expected = <Element[]>select(xpath.coreData.identifications.identification.name.content, dom);
+    expect(toTextArr(coreData.identifications.identification[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct begin performance date from XML", () => {
+    expect(coreData.beginPerformanceDate._text).toBe(select(xpath.coreData.beginPerformanceDate, dom));
+  });
+  test("should get correct end performance date from XML", () => {
+    expect(coreData.endPerformanceDate._text).toBe(select(xpath.coreData.endPerformanceDate, dom));
+  });
+  test("should get correct performance location from XML", () => {
+    expect(coreData.performanceLocation._text).toBe(select(xpath.coreData.performanceLocation, dom));
+  });
+
+  /* test for setters */
+  test("should set usedLangCodeISO639_1 correctly", () => {
+    fc.assert(
+      fc.property(string_ISO639_1(), (str) => {
+        // add new element to array
+        coreData.usedLangCodeISO639_1.push(new DCCXMLElement({ _text: str }));
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).toContain(str);
+        expect(toTextContentArr(actual)).toContain(str);
+      }),
+    );
+  });
+
+  test("should delete usedLangCodeISO639_1 correctly", () => {
+    const selection = toTextContentArr(<Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom));
+    fc.assert(
+      fc.property(fc.constantFrom(...selection), (str) => {
+        // get index and remove element from array
+        const index = indexOf(coreData.usedLangCodeISO639_1, str);
+        coreData.usedLangCodeISO639_1.splice(index, 1);
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).not.toContain(str);
+        expect(toTextContentArr(actual)).not.toContain(str);
+      }),
+    );
+  });
+});
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3888155b720d702e35bd3514808193b9d2da53a4
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
@@ -0,0 +1,42 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ContactType, DCCDocument, LocationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:customer";
+const xpath = {
+  customer: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    location: {
+      city: `${base}/dcc:location/dcc:city[1]`,
+    },
+  },
+};
+
+describe("Test_DCC_Minimal: ContactType", () => {
+  let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
+    location = customer.location; /* TODO: check iff this variable is used anywhere */
+  });
+
+  test("should get correct customer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.customer.name.content, dom);
+    expect(toTextArr(customer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct customer location city from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.city, dom);
+    expect(customer.location.city[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..958427c0ab62110e1b13ea66ff68257190bbbe55
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
@@ -0,0 +1,64 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { ItemType, DCCDocument, IdentificationType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:items";
+const xpath = {
+  items: {
+    item: {
+      name: {
+        content: `${base}/dcc:item[1]/dcc:name/dcc:content`,
+      },
+      manufacturer: {
+        name: {
+          content: `${base}/dcc:item[1]/dcc:manufacturer/dcc:name/dcc:content`,
+        },
+      },
+      identifications: {
+        identification: {
+          issuer: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+          value: `string(${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:value)`,
+          name: {
+            content: `${base}/dcc:item[1]/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+          },
+        },
+      },
+    },
+  },
+};
+
+describe("Test_DCC_Minimal: ItemType", () => {
+  let dcc: DCCDocument, item: ItemType, identification: IdentificationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
+    identification = item.identifications.identification[0];
+  });
+
+  test("should get correct item name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.name.content, dom);
+    expect(toTextArr(item.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct item manufacturer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.items.item.manufacturer.name.content, dom);
+    expect(toTextArr(item.manufacturer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct identification issuer from XML", () => {
+    expect(identification.issuer._text).toBe(select(xpath.items.item.identifications.identification.issuer, dom));
+  });
+
+  test("should get correct identification value from XML", () => {
+    expect(identification.value._text).toBe(select(xpath.items.item.identifications.identification.value, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7c74d6156dfb6a3ae2931778af04438753cdfcd9
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
@@ -0,0 +1,37 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { RespPersonType, DCCDocument } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:respPersons";
+const xpath = {
+  respPersons: {
+    respPerson: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[1]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+    },
+  },
+};
+
+describe("Test_DCC_Minimal: RespPersonType", () => {
+  let dcc: DCCDocument, respPerson: RespPersonType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    respPerson = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
+  });
+
+  test("should get correct responsible person 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson.person.name.content, dom);
+    expect(toTextArr(respPerson.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3577e44e913907b500a88a8880a88217d1cd4bf8
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
@@ -0,0 +1,41 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { SoftwareListType, DCCDocument, SoftwareType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:dccSoftware/dcc:software";
+const xpath = {
+  software: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    release: `string(${base}/dcc:release)`,
+    type: `string(${base}/dcc:type)`,
+    description: `${base}/dcc:description`,
+    _id: `${base}/@id`,
+    _refType: `${base}/@refType`,
+  },
+};
+
+describe("Test_DCC_Minimal: DccSoftwareType", () => {
+  let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
+    software = dccSoftware.software[0];
+  });
+
+  test("should get correct software name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.software.name.content, dom);
+    expect(toTextArr(software.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct software release version of software from XML", () => {
+    expect(software.release._text).toBe(select(xpath.software.release, dom));
+  });
+});
diff --git a/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts b/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1f0006a2ed27ebe21d73110cd8b29b3c318c7e14
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
@@ -0,0 +1,21 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select } from "../../util";
+
+const VERSION_XPATH = "string(/dcc:digitalCalibrationCertificate/@schemaVersion)";
+
+describe("Test_DCC_Minimal: DigitalCalibrationCertificateType", () => {
+  let xml, dcc, dom;
+
+  beforeEach(() => {
+    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+  });
+
+  test("should get correct schemaVersion from XML", () => {
+    const expectedVersion = select(VERSION_XPATH, dom);
+    expect(dcc.digitalCalibrationCertificate._attr.schemaVersion).toBe(expectedVersion);
+  });
+});
diff --git a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bd50cc089aebd932d39b73b02bea3d9baea30f7a
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
@@ -0,0 +1,35 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, MeasurementResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      name: {
+        content: `${base}/dcc:measurementResult[1]/dcc:name/dcc:content`,
+      },
+    },
+  },
+};
+
+describe("Test_DCC_Minimal: MeasurementResultType", () => {
+  let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
+  });
+
+  test("should get correct measurement result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.name.content, dom);
+    expect(toTextArr(measurementResult.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..06a09732589d26bcc61678da2d4b5ccd2bce0529
--- /dev/null
+++ b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
@@ -0,0 +1,100 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/Test_DCC_Minimal.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../../util";
+import { DCCDocument, ResultType } from "../../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:measurementResults/dcc:measurementResult[1]/dcc:results";
+const xpath = {
+  measurementResults: {
+    measurementResult: {
+      results: {
+        result: {
+          name: {
+            content: `${base}/dcc:result[1]/dcc:name/dcc:content`,
+          },
+          data: {
+            list: {
+              quantity: {
+                name: {
+                  content: `${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/dcc:name/dcc:content`,
+                },
+                si_hybrid: {
+                  si_realListXMLList1: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[1]/si:unitXMLList)`,
+                  },
+                  si_realListXMLList2: {
+                    si_valueXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:valueXMLList)`,
+                    si_unitXMLList: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]/si:hybrid/si:realListXMLList[2]/si:unitXMLList)`,
+                  },
+                },
+                refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list/dcc:quantity[1]//@refType)`,
+              },
+
+              refType: `string(${base}/dcc:result[1]/dcc:data/dcc:list//@refType)`,
+            },
+          },
+          refType: `string(${base}/dcc:result[1]//@refType)`,
+        },
+      },
+    },
+  },
+};
+
+describe("Test_DCC_Minimal: ResultType", () => {
+  let dcc: DCCDocument, result: ResultType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
+  });
+
+  test("should get correct result name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.measurementResults.measurementResult.results.result.name.content, dom);
+    expect(toTextArr(result.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct result quantity hybrid si:valueXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity.si_hybrid.si_realListXMLList1.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity hybrid si:unitXMLList 1 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[0].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity.si_hybrid.si_realListXMLList1.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity hybrid si:valueXMLList 2 from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].valueXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity.si_hybrid.si_realListXMLList2.si_valueXMLList, dom),
+    );
+  });
+
+  test("should get correct result quantity hybrid si:unitXMLList 2: from XML", () => {
+    expect(result.data.list[0].quantity[0].hybrid.realListXMLList[1].unitXMLList._text).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity.si_hybrid.si_realListXMLList2.si_unitXMLList, dom),
+    );
+  });
+
+  test("should get correct result refType from XML", () => {
+    expect(result._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.refType, dom));
+  });
+
+  test("should get correct result data list refType from XML", () => {
+    expect(result.data.list[0]._attr.refType).toBe(select(xpath.measurementResults.measurementResult.results.result.data.list.refType, dom));
+  });
+
+  test("should get correct result quantity 1 refType from XML", () => {
+    expect(result.data.list[0].quantity[0]._attr.refType).toBe(
+      select(xpath.measurementResults.measurementResult.results.result.data.list.quantity.refType, dom),
+    );
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts b/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
new file mode 100644
index 0000000000000000000000000000000000000000..25a455dc9475d0b92e64831ceaade2fbc96df271
--- /dev/null
+++ b/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
@@ -0,0 +1,78 @@
+import { select, toTextArr, toTextContentArr } from "../../../util";
+import { CalibrationLaboratoryType, DCCDocument } from "../../../../src";
+import { testRichContentType } from "../Types/RichContentType";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:calibrationLaboratory/dcc:contact";
+const xpath = {
+  name: `${base}/dcc:name`,
+  eMail: `string(${base}/dcc:eMail)`,
+  phone: `string(${base}/dcc:phone)`,
+  fax: `string(${base}/dcc:fax)`,
+  location: {
+    city: `${base}/dcc:location/dcc:city`,
+    countryCode: `${base}/dcc:location/dcc:countryCode`,
+    postCode: `${base}/dcc:location/dcc:postCode`,
+    street: `${base}/dcc:location/dcc:street`,
+    streetNo: `${base}/dcc:location/dcc:streetNo`,
+    further: `${base}/dcc:location/dcc:further/dcc:content`,
+  },
+};
+
+export const testCalibrationLaboratory = () => {
+  describe("CalibrationLaboratoryType", () => {
+    let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
+
+    beforeEach(() => {
+      ({ dcc, dom } = xmlEnv.recreateEnv());
+      calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
+    });
+
+    test("should get correct name from XML", () => {
+      testRichContentType(xpath.name, calibrationLaboratory.contact.name, dom);
+    });
+
+    test("should get correct eMail from XML", () => {
+      expect(calibrationLaboratory.contact.eMail._text).toBe(select(xpath.eMail, dom));
+    });
+
+    test("should get correct phone from XML", () => {
+      expect(calibrationLaboratory.contact.phone._text).toBe(select(xpath.phone, dom));
+    });
+
+    test("should get correct city from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.location.city, dom);
+      expect(toTextArr(calibrationLaboratory.contact.location.city)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct countryCode from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.location.countryCode, dom);
+      expect(toTextArr(calibrationLaboratory.contact.location.countryCode)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct postCode from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.location.postCode, dom);
+      expect(toTextArr(calibrationLaboratory.contact.location.postCode)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct street from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.location.street, dom);
+      expect(toTextArr(calibrationLaboratory.contact.location.street)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct streetNo from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.location.streetNo, dom);
+      expect(toTextArr(calibrationLaboratory.contact.location.streetNo)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct further element from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.location.further, dom);
+      expect(toTextArr(calibrationLaboratory.contact.location.further[0].content)).toEqual(toTextContentArr(expected));
+    });
+  });
+};
diff --git a/tests/DCC/common/AdministrativeData/CoreDataType.ts b/tests/DCC/common/AdministrativeData/CoreDataType.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ea974a5eea0dcdea35887302742d9576a470805f
--- /dev/null
+++ b/tests/DCC/common/AdministrativeData/CoreDataType.ts
@@ -0,0 +1,117 @@
+import * as fc from "fast-check";
+import { indexOf, select, toTextArr, toTextContentArr } from "../../../util";
+import { CoreDataType, DCCDocument, DCCXMLElement } from "../../../../src";
+import { string_ISO639_1 } from "../../../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:coreData";
+const xpath = {
+  coreData: {
+    countryCodeISO3166_1: `string(${base}/dcc:countryCodeISO3166_1)`,
+    usedLangCodeISO639_1: `${base}/dcc:usedLangCodeISO639_1`,
+    mandatoryLangCodeISO639_1: `${base}/dcc:mandatoryLangCodeISO639_1`,
+    uniqueIdentifier: `string(${base}/dcc:uniqueIdentifier)`,
+    identifications: {
+      identification: {
+        issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+        value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        name: {
+          content: `${base}/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+        },
+      },
+    },
+    receiptDate: `string(${base}/dcc:receiptDate)`,
+    beginPerformanceDate: `string(${base}/dcc:beginPerformanceDate)`,
+    endPerformanceDate: `string(${base}/dcc:endPerformanceDate)`,
+    performanceLocation: `string(${base}/dcc:performanceLocation)`,
+  },
+};
+
+export const testCoreData = () => {
+  describe("CoreDataType", () => {
+    let dcc: DCCDocument, coreData: CoreDataType, dom;
+
+    beforeEach(() => {
+      ({ dcc, dom } = xmlEnv.recreateEnv());
+      coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
+    });
+
+    test("should get correct countryCodeISO3166_1 from XML", () => {
+      expect(coreData.countryCodeISO3166_1._text).toBe(select(xpath.coreData.countryCodeISO3166_1, dom));
+    });
+
+    test("should get correct usedLangCodeISO639_1 from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom);
+      expect(toTextArr(coreData.usedLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct mandatoryLangCodeISO639_1 from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.coreData.mandatoryLangCodeISO639_1, dom);
+      expect(toTextArr(coreData.mandatoryLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct unique identifier from XML", () => {
+      expect(coreData.uniqueIdentifier._text).toBe(select(xpath.coreData.uniqueIdentifier, dom));
+    });
+
+    test("should get correct identification issuer from XML", () => {
+      expect(coreData.identifications.identification[0].issuer._text).toBe(select(xpath.coreData.identifications.identification.issuer, dom));
+    });
+
+    test("should get correct identification value from XML", () => {
+      expect(coreData.identifications.identification[0].value._text).toBe(select(xpath.coreData.identifications.identification.value, dom));
+    });
+
+    test("should get correct identification name content from XML", () => {
+      const expected = <Element[]>select(xpath.coreData.identifications.identification.name.content, dom);
+      expect(toTextArr(coreData.identifications.identification[0].name.content)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct receipt date from XML", () => {
+      expect(coreData.receiptDate._text).toBe(select(xpath.coreData.receiptDate, dom));
+    });
+    test("should get correct begin performance date from XML", () => {
+      expect(coreData.beginPerformanceDate._text).toBe(select(xpath.coreData.beginPerformanceDate, dom));
+    });
+    test("should get correct end performance date from XML", () => {
+      expect(coreData.endPerformanceDate._text).toBe(select(xpath.coreData.endPerformanceDate, dom));
+    });
+    test("should get correct performance location from XML", () => {
+      expect(coreData.performanceLocation._text).toBe(select(xpath.coreData.performanceLocation, dom));
+    });
+
+    /* test for setters */
+    test("should set usedLangCodeISO639_1 correctly", () => {
+      fc.assert(
+        fc.property(string_ISO639_1(), (str) => {
+          // add new element to array
+          coreData.usedLangCodeISO639_1.push(new DCCXMLElement({ _text: str }));
+
+          // get actual list from xml
+          const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+          expect(toTextArr(coreData.usedLangCodeISO639_1)).toContain(str);
+          expect(toTextContentArr(actual)).toContain(str);
+        }),
+      );
+    });
+
+    test("should delete usedLangCodeISO639_1 correctly", () => {
+      const selection = toTextContentArr(<Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom));
+      fc.assert(
+        fc.property(fc.constantFrom(...selection), (str) => {
+          // get index and remove element from array
+          const index = indexOf(coreData.usedLangCodeISO639_1, str);
+          coreData.usedLangCodeISO639_1.splice(index, 1);
+
+          // get actual list from xml
+          const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+          expect(toTextArr(coreData.usedLangCodeISO639_1)).not.toContain(str);
+          expect(toTextContentArr(actual)).not.toContain(str);
+        }),
+      );
+    });
+  });
+};
diff --git a/tests/DCC/common/AdministrativeData/RespPersons.ts b/tests/DCC/common/AdministrativeData/RespPersons.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88495a0fa0a5f732239ccebb886b05859e5700d0
--- /dev/null
+++ b/tests/DCC/common/AdministrativeData/RespPersons.ts
@@ -0,0 +1,19 @@
+import { select } from "../../../util";
+import { testRespPersonType } from "../Types/RespPersonType";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:respPersons";
+const xpath = {
+  respPerson: `${base}/dcc:respPerson`,
+};
+export const testRespPersonListType = () => {
+  describe("RespPersonListType", () => {
+    const { dom } = xmlEnv.recreateEnv();
+
+    const expectedRespPersons = <Element[]>select(xpath.respPerson, dom);
+    for (let i = 0; i < expectedRespPersons.length; i++) {
+      testRespPersonType(`${xpath.respPerson}[${i + 1}]`, (dcc) => dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[i]);
+    }
+
+    /* TODO: setters */
+  });
+};
diff --git a/tests/DCC/common/Types/ContactType.ts b/tests/DCC/common/Types/ContactType.ts
new file mode 100644
index 0000000000000000000000000000000000000000..07b0d211bf3cc99765372ba07df0610b9b7fc1de
--- /dev/null
+++ b/tests/DCC/common/Types/ContactType.ts
@@ -0,0 +1,72 @@
+import { ContactNotStrictType, ContactType, DCCDocument } from "../../../../src";
+import { select, toTextArr, toTextContentArr, undefinedIfEmpty } from "../../../util";
+
+export const testContactType = (base: string, contactTypeFn: (dcc: DCCDocument) => ContactType | ContactNotStrictType) => {
+  const xpath = {
+    customer: {
+      name: {
+        content: `${base}/dcc:name/dcc:content`,
+      },
+      email: `string(${base}/dcc:eMail)`,
+      phone: `string(${base}/dcc:phone)`,
+      fax: `string(${base}/dcc:fax)`,
+      location: {
+        city: `${base}/dcc:location/dcc:city[1]`,
+        countryCode: `${base}/dcc:location/dcc:countryCode[1]`,
+        postCode: `${base}/dcc:location/dcc:postCode[1]`,
+        postBoxOffice: `${base}/dcc:location/dcc:postBoxOffice[1]`,
+        state: `${base}/dcc:location/dcc:state[1]`,
+        street: `${base}/dcc:location/dcc:street[1]`,
+        streetNo: `${base}/dcc:location/dcc:streetNo[1]`,
+        further: `${base}/dcc:location/dcc:further[1]/dcc:content`,
+        positionCoordinates: `${base}/dcc:location/dcc:positionCoordinates[1]`,
+      },
+      descriptionData: `${base}/dcc:descriptionData`,
+      _id: `${base}/@id`,
+    },
+  };
+
+  describe("ContactType", () => {
+    let dcc: DCCDocument, contactType: ContactType | ContactNotStrictType, dom;
+
+    beforeEach(() => {
+      ({ dcc, dom } = xmlEnv.recreateEnv());
+      contactType = contactTypeFn(dcc);
+    });
+
+    test("should get correct customer name content from XML", () => {
+      // get expected list from example xml
+      const expected = <Element[]>select(xpath.customer.name.content, dom);
+      expect(toTextArr(contactType.name.content)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct customer email address from XML", () => {
+      expect(contactType.eMail?._text).toBe(undefinedIfEmpty(select(xpath.customer.email, dom)));
+    });
+
+    test("should get correct customer location city from XML", () => {
+      const expected = <Element[]>select(xpath.customer.location.city, dom);
+      expect(contactType.location?.city[0]._text).toEqual(toTextContentArr(expected)[0]);
+    });
+
+    test("should get correct customer location county code from XML", () => {
+      const expected = <Element[]>select(xpath.customer.location.countryCode, dom);
+      expect(contactType.location?.countryCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+    });
+
+    test("should get correct customer location post code from XML", () => {
+      const expected = <Element[]>select(xpath.customer.location.postCode, dom);
+      expect(contactType.location?.postCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+    });
+
+    test("should get correct customer location further from XML", () => {
+      const expected = <Element[]>select(xpath.customer.location.further, dom);
+
+      for (let i = 0; i < expected.length; i++) {
+        expect(contactType.location?.further[0].content[i]._text).toBe(expected[i].textContent);
+      }
+    });
+
+    /* TODO: setters */
+  });
+};
diff --git a/tests/DCC/common/Types/DataType.ts b/tests/DCC/common/Types/DataType.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e39bb763451c9ac85c21bfd5f6a15deb3ce277b4
--- /dev/null
+++ b/tests/DCC/common/Types/DataType.ts
@@ -0,0 +1,23 @@
+import { DataType, DCCDocument } from "../../../../src";
+import { select, toTextArr, toTextContentArr, undefinedIfEmpty } from "../../../util";
+
+export const testDataType = (base: string, dataTypeFn: (dcc: DCCDocument) => DataType) => {
+  const xpath = {
+    text: `${base}/dcc:text`,
+    quantity: `${base}/dcc:quantity`,
+    list: `${base}/dcc:list`,
+  };
+
+  describe("DataType", () => {
+    let dcc: DCCDocument, dataType: DataType, dom;
+
+    beforeEach(() => {
+      ({ dcc, dom } = xmlEnv.recreateEnv());
+      dataType = dataTypeFn(dcc);
+    });
+
+    test("noop", () => {});
+
+    // TODO(Statement): quantity with real
+  });
+};
diff --git a/tests/DCC/common/Types/RespPersonType.ts b/tests/DCC/common/Types/RespPersonType.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4284f9e9e59961d673eac1ffff77204c9eb6adee
--- /dev/null
+++ b/tests/DCC/common/Types/RespPersonType.ts
@@ -0,0 +1,28 @@
+import { DCCDocument, RespPersonType } from "../../../../src";
+import { select, undefinedIfEmpty } from "../../../util";
+import { testContactType } from "./ContactType";
+
+export const testRespPersonType = (base: string, respPersonTypeFn: (dcc: DCCDocument) => RespPersonType) => {
+  const xpath = {
+    person: `${base}/dcc:person`,
+    mainSigner: `string(${base}/dcc:mainSigner)`,
+  };
+
+  describe("RespPersonType", () => {
+    let dcc: DCCDocument, respPersonType: RespPersonType, dom;
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+
+    beforeEach(() => {
+      ({ dcc, dom } = xmlEnv.recreateEnv());
+      respPersonType = respPersonTypeFn(dcc);
+    });
+
+    testContactType(xpath.person, (dcc) => respPersonTypeFn(dcc).person);
+
+    test("should get correct responsible person main signer flag from XML", () => {
+      expect(respPersonType.mainSigner?._text).toBe(undefinedIfEmpty(select(xpath.mainSigner, dom)));
+    });
+
+    /* TODO: setters */
+  });
+};
diff --git a/tests/DCC/common/Types/RichContentType.ts b/tests/DCC/common/Types/RichContentType.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf873f0654937e4c6327a88411f34c96b238b123
--- /dev/null
+++ b/tests/DCC/common/Types/RichContentType.ts
@@ -0,0 +1,25 @@
+import { JSDOM } from "jsdom";
+import * as _ from "lodash";
+import { RichContentType } from "../../../../src";
+import { select } from "../../../util";
+
+const testContent = (base: string, richContent: RichContentType, dom: JSDOM) => {
+  const elements = <Element[]>select(`${base}/dcc:content`, dom);
+  // get expected langs from xml, filter out empty strings
+  const langs = _.uniq(elements.map((x) => x.getAttribute("lang")).filter((x) => x));
+  if(langs.length > 0) {
+    // check content for each lang if there are any
+    for (const lang of langs) {
+      expect(richContent.getContent(lang)._text).toBe(select(`string(${base}/dcc:content[@lang="${lang}"])`, dom));
+    }
+  } else {
+    // check content if there are no langs
+    expect(richContent.getContent()._text).toBe(select(`string(${base}/dcc:content)`, dom));
+  }
+}
+
+export const testRichContentType = (base: string, richContent: RichContentType, dom: JSDOM) => {
+  testContent(base, richContent, dom);
+  // TODO: test file
+  // TODO: test formula
+};
diff --git a/tests/DCC/common/Types/StatementListType.ts b/tests/DCC/common/Types/StatementListType.ts
new file mode 100644
index 0000000000000000000000000000000000000000..254fda4055e15b176321814056dbf7cc918a6641
--- /dev/null
+++ b/tests/DCC/common/Types/StatementListType.ts
@@ -0,0 +1,18 @@
+import { select } from "../../../util";
+import { testStatementMetaDataType } from "./StatementMetaDataType";
+import { DCCDocument, StatementListType } from "../../../../src";
+
+export const testStatementListType = (base, statementListTypeFn: (dcc: DCCDocument) => StatementListType) => {
+  const xpath = {
+    statement: `${base}/dcc:statement`,
+  };
+
+  describe("StatementListType", () => {
+    const { dom } = xmlEnv.recreateEnv();
+
+    const expectedStatements = <Element[]>select(xpath.statement, dom);
+    for (let i = 0; i < expectedStatements.length; i++) {
+      testStatementMetaDataType(i, `${xpath.statement}[${i + 1}]`, (dcc) => statementListTypeFn(dcc).statement[i]);
+    }
+  });
+};
diff --git a/tests/DCC/common/Types/StatementMetaDataType.ts b/tests/DCC/common/Types/StatementMetaDataType.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e09d863652e38288590ea89d2124ffe2b5a7383
--- /dev/null
+++ b/tests/DCC/common/Types/StatementMetaDataType.ts
@@ -0,0 +1,72 @@
+import { DCCDocument, StatementMetaDataType } from "../../../../src";
+import { select, toTextArr, toTextContentArr, undefinedIfEmpty } from "../../../util";
+import { testContactType } from "./ContactType";
+import { testDataType } from "./DataType";
+
+export const testStatementMetaDataType = (name, base: string, statementMetaDataTypeFn: (dcc: DCCDocument) => StatementMetaDataType) => {
+  const xpath = {
+    norm: `${base}/dcc:norm`,
+    reference: `${base}/dcc:reference`,
+    declaration: {
+      content: `${base}/dcc:declaration/dcc:content`,
+    },
+    conformity: `string(${base}/dcc:conformity)`,
+    date: `string(${base}/dcc:date)`,
+    respAuthority: `${base}/dcc:respAuthority`,
+    data: `${base}/dcc:data`,
+
+    refType: `string(${base}/@refType)`,
+  };
+
+  describe(`StatementMetaDataType ${name}`, () => {
+    let dcc: DCCDocument, statementMetaDataType: StatementMetaDataType, dom;
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+
+    beforeEach(() => {
+      ({ dcc, dom } = xmlEnv.recreateEnv());
+      statementMetaDataType = statementMetaDataTypeFn(dcc);
+    });
+
+    const hasContact = <boolean>select(`boolean(${xpath.respAuthority})`, dom);
+    if (hasContact) {
+      testContactType(xpath.respAuthority, (dcc) => statementMetaDataTypeFn(dcc).respAuthority);
+    }
+
+    const hasData = <boolean>select(`boolean(${xpath.data})`, dom);
+    if (hasData) {
+      testDataType(xpath.data, (dcc) => statementMetaDataTypeFn(dcc).data);
+    }
+
+    test("should get correct statement declaration content from XML", () => {
+      const expected = <Element[]>select(xpath.declaration.content, dom);
+      expect(toTextArr(statementMetaDataType.declaration?.content)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct statement norm model from XML", () => {
+      const expected = <Element[]>select(xpath.norm, dom);
+      expect(toTextArr(statementMetaDataType.norm)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct statement reference from XML", () => {
+      const expected = <Element[]>select(xpath.reference, dom);
+      expect(toTextArr(statementMetaDataType.reference)).toEqual(toTextContentArr(expected));
+    });
+
+    test("should get correct statement refType from XML", () => {
+      const expected = select(xpath.refType, dom);
+      expect(statementMetaDataType._attr.refType).toBe(undefinedIfEmpty(expected));
+    });
+
+    test("should get correct statement conformity from XML", () => {
+      const expected = select(xpath.conformity, dom);
+      expect(statementMetaDataType.conformity?._text).toBe(undefinedIfEmpty(expected));
+    });
+
+    test("should get correct statement date from XML", () => {
+      const expected = select(xpath.date, dom);
+      expect(statementMetaDataType.date?._text).toBe(undefinedIfEmpty(expected));
+    });
+
+    /* TODO: setters */
+  });
+};
diff --git a/tests/DCCDocument.test.ts b/tests/DCCDocument.test.ts
index 3e1d88919b741ac2cfc6b78369fa83bbc68348d8..06dccbf35bc53914da529ad3169ca413a3713a38 100644
--- a/tests/DCCDocument.test.ts
+++ b/tests/DCCDocument.test.ts
@@ -1,12 +1,20 @@
-import { DCCDocument } from "../src";
-import { xml } from "./Resources/example.xml";
-import { expect } from "chai";
-import { describe, it } from "mocha";
-
-describe("DCCDocument",
-  () => {
-    it("should not modify XML", () => {
-      let dcc = DCCDocument.fromXml(xml);
-      expect(dcc.toXML()).to.be.equal(xml);
-    });
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/example.xml
+ */
+
+describe("DCCDocument", () => {
+  let xml, dcc;
+
+  beforeEach(() => {
+    ({ xml, dcc } = xmlEnv.recreateEnv());
+  });
+
+  test("fromXml() and toXml() should not modify XML", () => {
+    // fix line endings, they are always LF
+    xml = xml.replace(/\r\n|\r|\n/g, "\n");
+
+    // fromXml() is part of the XMLEnvironment
+    expect(dcc.toXML()).toBe(xml);
   });
+});
diff --git a/tests/GP_Temperature/CharsXMLList.test.ts b/tests/GP_Temperature/CharsXMLList.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ac10b24c8bb6ea5acfc581e0768b5c9e7e30f008
--- /dev/null
+++ b/tests/GP_Temperature/CharsXMLList.test.ts
@@ -0,0 +1,25 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select } from "../util";
+import { DCCDocument } from "../../src";
+
+const base = "//dcc:quantity[@refType='test_charsXMLList']";
+const xpath = {
+  charsXMLList: `string(${base}/dcc:charsXMLList)`,
+};
+
+describe("CharsXMLList", () => {
+  let dcc: DCCDocument, dom, result;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
+  });
+
+  test("should get correct charsXMLList from XML", () => {
+    expect(result.data.quantity[1].charsXMLList._text).toBe(select(xpath.charsXMLList, dom));
+  });
+});
diff --git a/tests/GP_Temperature/noQuantity.test.ts b/tests/GP_Temperature/noQuantity.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8b8bc095dfebd32e594f79bacf4ab83106840592
--- /dev/null
+++ b/tests/GP_Temperature/noQuantity.test.ts
@@ -0,0 +1,56 @@
+/**
+ * @jest-environment ./tests/XMLEnvironment.ts
+ * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { DCCDocument } from "../../src";
+
+const base = "//dcc:quantity[@refType='test_noQuantity']/dcc:noQuantity";
+const xpath = {
+  noQuantity: {
+    name: {
+      content: `string(${base}/dcc:name/dcc:content)`,
+    },
+    content: `string(${base}/dcc:content)`,
+    file: {
+      fileName: `string(${base}/dcc:file/dcc:fileName)`,
+      mimeType: `string(${base}/dcc:file/dcc:mimeType)`,
+      dataBase64: `string(${base}/dcc:file/dcc:dataBase64)`,
+    },
+    formula: {
+      latex: `string(${base}/dcc:formula/dcc:latex)`,
+    },
+  },
+};
+
+describe("noQuantity", () => {
+  let dcc: DCCDocument, dom, result;
+
+  beforeEach(() => {
+    ({ dcc, dom } = xmlEnv.recreateEnv());
+    result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
+  });
+
+  test("should get correct name from XML", () => {
+    const expected = <Element[]>select(xpath.noQuantity.name.content, dom);
+
+    expect(toTextArr(result.data.quantity[0].noQuantity.name.content)[0]).toBe(expected);
+  });
+
+  test("should get correct content from XML", () => {
+    expect(result.data.quantity[0].noQuantity.content[0]._text).toBe(select(xpath.noQuantity.content, dom));
+  });
+
+  test("should get correct fileName from XML", () => {
+    expect(result.data.quantity[0].noQuantity.file[0].fileName._text).toBe(select(xpath.noQuantity.file.fileName, dom));
+  });
+
+  test("should get correct mimeType from XML", () => {
+    expect(result.data.quantity[0].noQuantity.file[0].mimeType._text).toBe(select(xpath.noQuantity.file.mimeType, dom));
+  });
+
+  test("should get correct latex formula from XML", () => {
+    expect(result.data.quantity[0].noQuantity.formula[0].latex._text).toBe(select(xpath.noQuantity.formula.latex, dom));
+  });
+});
diff --git a/tests/XMLEnvironment.ts b/tests/XMLEnvironment.ts
new file mode 100644
index 0000000000000000000000000000000000000000..10160dec3084e38d0a56f4aef1bbe4e3a61e9f99
--- /dev/null
+++ b/tests/XMLEnvironment.ts
@@ -0,0 +1,44 @@
+import * as fs from "fs/promises";
+import { DCCDocument } from "../src";
+import NodeEnvironment from "jest-environment-node";
+import { JSDOM } from "jsdom";
+
+export default class XMLEnvironment extends NodeEnvironment {
+  xmlPath: string;
+  xml: string;
+
+  constructor(config, context) {
+    super(config, context);
+    const xmlPath = context.docblockPragmas["xml"];
+    if (xmlPath && typeof xmlPath === "string") {
+      this.xmlPath = xmlPath;
+    }
+  }
+
+  async setup() {
+    await super.setup();
+    if (this.xmlPath) {
+      this.xml = await this.readFile(this.xmlPath);
+    }
+    this.global.xmlEnv = this;
+  }
+
+  recreateEnv(): { xml: string; dcc: DCCDocument; dom: JSDOM } {
+    return {
+      xml: this.xml,
+      dcc: this.xml ? DCCDocument.fromXml(this.xml) : DCCDocument.createEmpty(),
+      dom: new JSDOM(this.xml, { contentType: "application/xml" }),
+    };
+  }
+
+  async readFile(path: string) {
+    // check if file exists
+    if ((await fs.stat(path)).isFile()) {
+      return await fs.readFile(path, { encoding: "utf-8" });
+    } else {
+      throw new Error(`File ${path} does not exist.`);
+    }
+  }
+}
+
+export const TestEnvironment = XMLEnvironment;
diff --git a/tests/index.d.ts b/tests/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..facbc06803c5991082187188c3fe4ea62972402a
--- /dev/null
+++ b/tests/index.d.ts
@@ -0,0 +1,12 @@
+import XMLEnvironment from "./XMLEnvironment";
+
+declare let xmlEnv: XMLEnvironment;
+
+declare global {
+  let xmlEnv: XMLEnvironment;
+  namespace NodeJS {
+    interface Global {
+      xmlEnv: XMLEnvironment;
+    }
+  }
+}
diff --git a/tests/resources/GP_Temperature_Simplified.xml b/tests/resources/GP_Temperature_Simplified.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7d299d4b394052aaee1316f1bc9a945247dfcc99
--- /dev/null
+++ b/tests/resources/GP_Temperature_Simplified.xml
@@ -0,0 +1,352 @@
+<?xml version="1.0" encoding="utf-8"?>
+<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcc="https://ptb.de/dcc" xmlns:si="https://ptb.de/si" xsi:schemaLocation="https://ptb.de/dcc https://ptb.de/dcc/v3.2.0/dcc.xsd" schemaVersion="3.2.0">
+    <dcc:administrativeData>
+        <dcc:dccSoftware>
+            <dcc:software>
+                <dcc:name>
+                    <dcc:content>Notepad++ (32-bit)</dcc:content>
+                </dcc:name>
+                <dcc:release>v 8.2</dcc:release>
+            </dcc:software>
+        </dcc:dccSoftware>
+        <dcc:coreData>
+            <dcc:countryCodeISO3166_1>DE</dcc:countryCodeISO3166_1>
+            <dcc:usedLangCodeISO639_1>en</dcc:usedLangCodeISO639_1>
+            <dcc:usedLangCodeISO639_1>de</dcc:usedLangCodeISO639_1>
+            <dcc:mandatoryLangCodeISO639_1>en</dcc:mandatoryLangCodeISO639_1>
+            <dcc:uniqueIdentifier>GP_DCC_temperature_minimal_1.2</dcc:uniqueIdentifier>
+            <dcc:identifications>
+                <dcc:identification>
+                    <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                    <dcc:value>string-calibrationLaboratory-coreData</dcc:value>
+                    <dcc:name>
+                        <dcc:content lang="de">Auftrags Nr.</dcc:content>
+                        <dcc:content lang="en">Order no.</dcc:content>
+                    </dcc:name>
+                </dcc:identification>
+            </dcc:identifications>
+            <dcc:beginPerformanceDate>1957-08-13</dcc:beginPerformanceDate>
+            <dcc:endPerformanceDate>1957-08-13</dcc:endPerformanceDate>
+            <dcc:performanceLocation>laboratory</dcc:performanceLocation>
+        </dcc:coreData>
+        <dcc:items>
+            <dcc:item>
+                <dcc:name>
+                    <dcc:content lang="de">Temperatur-Fühler</dcc:content>
+                    <dcc:content lang="en">Temperature sensor</dcc:content>
+                </dcc:name>
+                <dcc:manufacturer>
+                    <dcc:name>
+                        <dcc:content>String</dcc:content>
+                    </dcc:name>
+                </dcc:manufacturer>
+                <dcc:model>String</dcc:model>
+                <dcc:identifications>
+                    <dcc:identification>
+                        <dcc:issuer>manufacturer</dcc:issuer>
+                        <dcc:value>string-manufacturer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Serien Nr.</dcc:content>
+                            <dcc:content lang="en">Serial no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>customer</dcc:issuer>
+                        <dcc:value>string-customer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Messmittel Nr.</dcc:content>
+                            <dcc:content lang="en">Measurement equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                        <dcc:value>string-calibrationLaboratory-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Equipment Nr.</dcc:content>
+                            <dcc:content lang="en">Equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                </dcc:identifications>
+            </dcc:item>
+        </dcc:items>
+        <dcc:calibrationLaboratory>
+            <dcc:contact>
+                <dcc:name>
+                    <dcc:content>Kalibrierfirma GmbH</dcc:content>
+                </dcc:name>
+                <dcc:eMail>info@kalibrierfirma.xx</dcc:eMail>
+                <dcc:phone>+49 123 4567-89</dcc:phone>
+                <dcc:fax>+49 123 4567-90</dcc:fax>
+                <dcc:location>
+                    <dcc:city>Musterstadt</dcc:city>
+                    <dcc:countryCode>DE</dcc:countryCode>
+                    <dcc:postCode>00900</dcc:postCode>
+                    <dcc:street>Musterstraße</dcc:street>
+                    <dcc:streetNo>1</dcc:streetNo>
+                    <dcc:further>
+                        <dcc:content>www.kalibrierfirma.xx</dcc:content>
+                    </dcc:further>
+                </dcc:location>
+            </dcc:contact>
+        </dcc:calibrationLaboratory>
+        <dcc:respPersons>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michaela Musterfrau</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+                <dcc:mainSigner>true</dcc:mainSigner>
+            </dcc:respPerson>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michael Mustermann</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+            </dcc:respPerson>
+        </dcc:respPersons>
+        <dcc:customer>
+            <dcc:name>
+                <dcc:content>Kunde GmbH</dcc:content>
+            </dcc:name>
+            <dcc:eMail>info@kunde.xx</dcc:eMail>
+            <dcc:location>
+                <dcc:city>Musterstadt</dcc:city>
+                <dcc:countryCode>DE</dcc:countryCode>
+                <dcc:postCode>00900</dcc:postCode>
+                <dcc:further>
+                    <dcc:content lang="de">Kunden Nr. 1024418</dcc:content>
+                    <dcc:content lang="en">Customer ID no. 1024418</dcc:content>
+                </dcc:further>
+            </dcc:location>
+        </dcc:customer>
+        <dcc:statements>
+            <dcc:statement refType="basic_conformity">
+                <dcc:declaration>
+                    <dcc:content lang="de">Die Konformitätsaussage erfolgt anhand der Vorgaben des Kunden. Sie sind im DCC mit aufgeführt.</dcc:content>
+                    <dcc:content lang="en">The conformity statement is made on the basis of the customer's specifications. They are listed in the DCC.</dcc:content>
+                </dcc:declaration>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+                <dcc:conformity>pass</dcc:conformity>
+            </dcc:statement>
+            <dcc:statement refType="basic_recalibration">
+                <dcc:declaration>
+                    <dcc:content lang="de">Datum, wann nach der Festlegung durch den Kunden spätestens der Kalibriergegenstand rekalibriert werden soll:</dcc:content>
+                    <dcc:content lang="en">Date when the calibration item is to be recalibrated at the latest according to the customer's specification:</dcc:content>
+                </dcc:declaration>
+                <dcc:date>1959-10-22</dcc:date>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+            </dcc:statement>
+        </dcc:statements>
+    </dcc:administrativeData>
+    <dcc:measurementResults>
+        <dcc:measurementResult>
+            <dcc:name>
+                <dcc:content lang="de">Messergebnisse</dcc:content>
+                <dcc:content lang="en">Measurement results</dcc:content>
+            </dcc:name>
+            <dcc:usedMethods>
+                <dcc:usedMethod refType="gp_temperatureSensor">
+                    <dcc:name>
+                        <dcc:content lang="de">Kalibrierung von Temperaturmessfühlern</dcc:content>
+                        <dcc:content lang="en">Calibration of temperature sensors</dcc:content>
+                    </dcc:name>
+                </dcc:usedMethod>
+            </dcc:usedMethods>
+            <dcc:measuringEquipments>
+                <dcc:measuringEquipment refType="basic_normalUsed">
+                    <dcc:name>
+                        <dcc:content lang="de">Pt 100 Widerstandsthermometer</dcc:content>
+                        <dcc:content lang="en">Pt 100 thermometer</dcc:content>
+                    </dcc:name>
+                    <dcc:identifications>
+                        <dcc:identification>
+                            <dcc:issuer>manufacturer</dcc:issuer>
+                            <dcc:value>string-manufacturer-measuringEquipment-1</dcc:value>
+                        </dcc:identification>
+                    </dcc:identifications>
+                </dcc:measuringEquipment>
+            </dcc:measuringEquipments>
+            <dcc:influenceConditions>
+                <dcc:influenceCondition refType="basic_temperature">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung Temperatur</dcc:content>
+                        <dcc:content lang="en">Ambient condition temperature</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_temperatureMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur min</dcc:content>
+                                <dcc:content lang="en">temperature min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>293</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_temperatureMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur max</dcc:content>
+                                <dcc:content lang="en">temperature max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>299</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+                <dcc:influenceCondition refType="basic_humidityRelative">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung relative Luftfeuchte</dcc:content>
+                        <dcc:content lang="en">Ambient condition relative humidity</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_humidityRelativeMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte min</dcc:content>
+                                <dcc:content lang="en">humidity min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.20</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_humidityRelativeMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte max</dcc:content>
+                                <dcc:content lang="en">humidity max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.70</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+            </dcc:influenceConditions>
+            <dcc:results>
+                <dcc:result refType="gp_measuringResult1">
+                    <dcc:name>
+                        <dcc:content lang="de">Messergebnisse</dcc:content>
+                        <dcc:content lang="en">Measuring results</dcc:content>
+                    </dcc:name>
+                    <dcc:data>
+                        <dcc:list refType="gp_table1">
+                            <dcc:quantity refType="basic_referenceValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Bezugswert</dcc:content>
+                                    <dcc:content lang="en">Reference value</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.098 99.971 175.103 250.169 320.004</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measuredValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Angezeigter Messwert Kalibriergegenstand</dcc:content>
+                                    <dcc:content lang="en">Indicated measured value probe</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.32 373.21 448.36 523.31 593.07</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.17 100.06 175.21 250.16 319.92</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measurementError">
+                                <dcc:name>
+                                    <dcc:content lang="de">Messabweichung</dcc:content>
+                                    <dcc:content lang="en">Measurement error</dcc:content>
+                                </dcc:name>
+                                <si:realListXMLList>
+                                    <si:valueXMLList>0.072 0.089 0.107 -0.009 -0.084</si:valueXMLList>
+                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    <si:expandedUncXMLList>
+                                        <si:uncertaintyXMLList>0.061</si:uncertaintyXMLList>
+                                        <si:coverageFactorXMLList>2</si:coverageFactorXMLList>
+                                        <si:coverageProbabilityXMLList>0.95</si:coverageProbabilityXMLList>
+                                        <si:distributionXMLList>normal</si:distributionXMLList>
+                                    </si:expandedUncXMLList>
+                                </si:realListXMLList>
+                                <dcc:measurementMetaData>
+                                    <dcc:metaData refType="basic_conformity">
+                                        <dcc:declaration>
+                                            <dcc:name>
+                                                <dcc:content lang="de">Konformität</dcc:content>
+                                                <dcc:content lang="en">Conformity</dcc:content>
+                                            </dcc:name>
+                                        </dcc:declaration>
+                                        <dcc:conformityXMLList>pass</dcc:conformityXMLList>
+                                        <dcc:data>
+                                            <dcc:quantity refType="basic_acceptanceLimitLower">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Unteres Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Lower acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>-0.23 -0.23 -0.23 -0.30 -0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                            <dcc:quantity refType="basic_acceptanceLimitUpper">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Oberes Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Upper acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>0.23 0.23 0.23 0.30 0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                        </dcc:data>
+                                    </dcc:metaData>
+                                </dcc:measurementMetaData>
+                            </dcc:quantity>
+                        </dcc:list>
+                    </dcc:data>
+                </dcc:result>
+            </dcc:results>
+        </dcc:measurementResult>
+    </dcc:measurementResults>
+</dcc:digitalCalibrationCertificate>
\ No newline at end of file
diff --git a/tests/resources/GP_Temperature_Simplified_variant.xml b/tests/resources/GP_Temperature_Simplified_variant.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6001e422ece1beb8be4b6b8a1f6f5e511b8dd68e
--- /dev/null
+++ b/tests/resources/GP_Temperature_Simplified_variant.xml
@@ -0,0 +1,365 @@
+<?xml version="1.0" encoding="utf-8"?>
+<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcc="https://ptb.de/dcc" xmlns:si="https://ptb.de/si" xsi:schemaLocation="https://ptb.de/dcc https://ptb.de/dcc/v3.2.0/dcc.xsd" schemaVersion="3.2.0">
+    <dcc:administrativeData>
+        <dcc:dccSoftware>
+            <dcc:software>
+                <dcc:name>
+                    <dcc:content>Notepad++ (32-bit)</dcc:content>
+                </dcc:name>
+                <dcc:release>v 8.2</dcc:release>
+            </dcc:software>
+        </dcc:dccSoftware>
+        <dcc:coreData>
+            <dcc:countryCodeISO3166_1>DE</dcc:countryCodeISO3166_1>
+            <dcc:usedLangCodeISO639_1>en</dcc:usedLangCodeISO639_1>
+            <dcc:usedLangCodeISO639_1>de</dcc:usedLangCodeISO639_1>
+            <dcc:mandatoryLangCodeISO639_1>en</dcc:mandatoryLangCodeISO639_1>
+            <dcc:uniqueIdentifier>GP_DCC_temperature_minimal_1.2</dcc:uniqueIdentifier>
+            <dcc:identifications>
+                <dcc:identification>
+                    <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                    <dcc:value>string-calibrationLaboratory-coreData</dcc:value>
+                    <dcc:name>
+                        <dcc:content lang="de">Auftrags Nr.</dcc:content>
+                        <dcc:content lang="en">Order no.</dcc:content>
+                    </dcc:name>
+                </dcc:identification>
+            </dcc:identifications>
+            <dcc:beginPerformanceDate>1957-08-13</dcc:beginPerformanceDate>
+            <dcc:endPerformanceDate>1957-08-13</dcc:endPerformanceDate>
+            <dcc:performanceLocation>laboratory</dcc:performanceLocation>
+        </dcc:coreData>
+        <dcc:items>
+            <dcc:item>
+                <dcc:name>
+                    <dcc:content lang="de">Temperatur-Fühler</dcc:content>
+                    <dcc:content lang="en">Temperature sensor</dcc:content>
+                </dcc:name>
+                <dcc:equipmentClass>
+                    <dcc:reference>1.2.3.4.5</dcc:reference>
+                    <dcc:classID>12345</dcc:classID>
+                </dcc:equipmentClass>
+                <dcc:manufacturer>
+                    <dcc:name>
+                        <dcc:content>String</dcc:content>
+                    </dcc:name>
+                </dcc:manufacturer>
+                <dcc:model>String</dcc:model>
+                <dcc:identifications>
+                    <dcc:identification>
+                        <dcc:issuer>manufacturer</dcc:issuer>
+                        <dcc:value>string-manufacturer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Serien Nr.</dcc:content>
+                            <dcc:content lang="en">Serial no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>customer</dcc:issuer>
+                        <dcc:value>string-customer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Messmittel Nr.</dcc:content>
+                            <dcc:content lang="en">Measurement equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                        <dcc:value>string-calibrationLaboratory-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Equipment Nr.</dcc:content>
+                            <dcc:content lang="en">Equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                </dcc:identifications>
+            </dcc:item>
+        </dcc:items>
+        <dcc:calibrationLaboratory>
+            <dcc:contact>
+                <dcc:name>
+                    <dcc:content>Kalibrierfirma GmbH</dcc:content>
+                </dcc:name>
+                <dcc:eMail>info@kalibrierfirma.xx</dcc:eMail>
+                <dcc:phone>+49 123 4567-89</dcc:phone>
+                <dcc:fax>+49 123 4567-90</dcc:fax>
+                <dcc:location>
+                    <dcc:city>Musterstadt</dcc:city>
+                    <dcc:countryCode>DE</dcc:countryCode>
+                    <dcc:postCode>00900</dcc:postCode>
+                    <dcc:street>Musterstraße</dcc:street>
+                    <dcc:streetNo>1</dcc:streetNo>
+                    <dcc:further>
+                        <dcc:content>www.kalibrierfirma.xx</dcc:content>
+                    </dcc:further>
+                </dcc:location>
+            </dcc:contact>
+        </dcc:calibrationLaboratory>
+        <dcc:respPersons>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michaela Musterfrau</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+                <dcc:mainSigner>true</dcc:mainSigner>
+            </dcc:respPerson>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michael Mustermann</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+            </dcc:respPerson>
+        </dcc:respPersons>
+        <dcc:customer>
+            <dcc:name>
+                <dcc:content>Kunde GmbH</dcc:content>
+            </dcc:name>
+            <dcc:eMail>info@kunde.xx</dcc:eMail>
+            <dcc:location>
+                <dcc:city>Musterstadt</dcc:city>
+                <dcc:countryCode>DE</dcc:countryCode>
+                <dcc:postCode>00900</dcc:postCode>
+                <dcc:further>
+                    <dcc:content lang="de">Kunden Nr. 1024418</dcc:content>
+                    <dcc:content lang="en">Customer ID no. 1024418</dcc:content>
+                </dcc:further>
+            </dcc:location>
+        </dcc:customer>
+        <dcc:statements>
+            <dcc:statement refType="basic_conformity">
+                <dcc:declaration>
+                    <dcc:content lang="de">Die Konformitätsaussage erfolgt anhand der Vorgaben des Kunden. Sie sind im DCC mit aufgeführt.</dcc:content>
+                    <dcc:content lang="en">The conformity statement is made on the basis of the customer's specifications. They are listed in the DCC.</dcc:content>
+                </dcc:declaration>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+                <dcc:conformity>pass</dcc:conformity>
+            </dcc:statement>
+            <dcc:statement refType="basic_recalibration">
+                <dcc:declaration>
+                    <dcc:content lang="de">Datum, wann nach der Festlegung durch den Kunden spätestens der Kalibriergegenstand rekalibriert werden soll:</dcc:content>
+                    <dcc:content lang="en">Date when the calibration item is to be recalibrated at the latest according to the customer's specification:</dcc:content>
+                </dcc:declaration>
+                <dcc:date>1959-10-22</dcc:date>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+            </dcc:statement>
+            <dcc:statement>
+                <dcc:countryCodeISO3166_1>DE</dcc:countryCodeISO3166_1>
+                <dcc:countryCodeISO3166_1>US</dcc:countryCodeISO3166_1>
+                <dcc:convention>abcde</dcc:convention>
+                <dcc:traceable>true</dcc:traceable>
+                <dcc:period>P1Y2M3DT10H30M</dcc:period>
+                <dcc:nonSIDefinition>abcde_definition</dcc:nonSIDefinition>
+                <dcc:nonSIUnit>abcde_unit</dcc:nonSIUnit>
+            </dcc:statement>
+        </dcc:statements>
+    </dcc:administrativeData>
+    <dcc:measurementResults>
+        <dcc:measurementResult>
+            <dcc:name>
+                <dcc:content lang="de">Messergebnisse</dcc:content>
+                <dcc:content lang="en">Measurement results</dcc:content>
+            </dcc:name>
+            <dcc:usedMethods>
+                <dcc:usedMethod refType="gp_temperatureSensor">
+                    <dcc:name>
+                        <dcc:content lang="de">Kalibrierung von Temperaturmessfühlern</dcc:content>
+                        <dcc:content lang="en">Calibration of temperature sensors</dcc:content>
+                    </dcc:name>
+                </dcc:usedMethod>
+            </dcc:usedMethods>
+            <dcc:measuringEquipments>
+                <dcc:measuringEquipment refType="basic_normalUsed">
+                    <dcc:name>
+                        <dcc:content lang="de">Pt 100 Widerstandsthermometer</dcc:content>
+                        <dcc:content lang="en">Pt 100 thermometer</dcc:content>
+                    </dcc:name>
+                    <dcc:identifications>
+                        <dcc:identification>
+                            <dcc:issuer>manufacturer</dcc:issuer>
+                            <dcc:value>string-manufacturer-measuringEquipment-1</dcc:value>
+                        </dcc:identification>
+                    </dcc:identifications>
+                </dcc:measuringEquipment>
+            </dcc:measuringEquipments>
+            <dcc:influenceConditions>
+                <dcc:influenceCondition refType="basic_temperature">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung Temperatur</dcc:content>
+                        <dcc:content lang="en">Ambient condition temperature</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_temperatureMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur min</dcc:content>
+                                <dcc:content lang="en">temperature min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>293</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_temperatureMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur max</dcc:content>
+                                <dcc:content lang="en">temperature max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>299</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+                <dcc:influenceCondition refType="basic_humidityRelative">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung relative Luftfeuchte</dcc:content>
+                        <dcc:content lang="en">Ambient condition relative humidity</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_humidityRelativeMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte min</dcc:content>
+                                <dcc:content lang="en">humidity min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.20</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_humidityRelativeMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte max</dcc:content>
+                                <dcc:content lang="en">humidity max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.70</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+            </dcc:influenceConditions>
+            <dcc:results>
+                <dcc:result refType="gp_measuringResult1">
+                    <dcc:name>
+                        <dcc:content lang="de">Messergebnisse</dcc:content>
+                        <dcc:content lang="en">Measuring results</dcc:content>
+                    </dcc:name>
+                    <dcc:data>
+                        <dcc:list refType="gp_table1">
+                            <dcc:quantity refType="basic_referenceValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Bezugswert</dcc:content>
+                                    <dcc:content lang="en">Reference value</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.098 99.971 175.103 250.169 320.004</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measuredValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Angezeigter Messwert Kalibriergegenstand</dcc:content>
+                                    <dcc:content lang="en">Indicated measured value probe</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.32 373.21 448.36 523.31 593.07</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.17 100.06 175.21 250.16 319.92</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measurementError">
+                                <dcc:name>
+                                    <dcc:content lang="de">Messabweichung</dcc:content>
+                                    <dcc:content lang="en">Measurement error</dcc:content>
+                                </dcc:name>
+                                <si:realListXMLList>
+                                    <si:valueXMLList>0.072 0.089 0.107 -0.009 -0.084</si:valueXMLList>
+                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    <si:expandedUncXMLList>
+                                        <si:uncertaintyXMLList>0.061</si:uncertaintyXMLList>
+                                        <si:coverageFactorXMLList>2</si:coverageFactorXMLList>
+                                        <si:coverageProbabilityXMLList>0.95</si:coverageProbabilityXMLList>
+                                        <si:distributionXMLList>normal</si:distributionXMLList>
+                                    </si:expandedUncXMLList>
+                                </si:realListXMLList>
+                                <dcc:measurementMetaData>
+                                    <dcc:metaData refType="basic_conformity">
+                                        <dcc:declaration>
+                                            <dcc:name>
+                                                <dcc:content lang="de">Konformität</dcc:content>
+                                                <dcc:content lang="en">Conformity</dcc:content>
+                                            </dcc:name>
+                                        </dcc:declaration>
+                                        <dcc:conformityXMLList>pass</dcc:conformityXMLList>
+                                        <dcc:data>
+                                            <dcc:quantity refType="basic_acceptanceLimitLower">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Unteres Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Lower acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>-0.23 -0.23 -0.23 -0.30 -0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                            <dcc:quantity refType="basic_acceptanceLimitUpper">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Oberes Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Upper acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>0.23 0.23 0.23 0.30 0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                        </dcc:data>
+                                    </dcc:metaData>
+                                </dcc:measurementMetaData>
+                            </dcc:quantity>
+                        </dcc:list>
+                    </dcc:data>
+                </dcc:result>
+            </dcc:results>
+        </dcc:measurementResult>
+    </dcc:measurementResults>
+</dcc:digitalCalibrationCertificate>
diff --git a/tests/resources/GP_Temperature_Typical.xml b/tests/resources/GP_Temperature_Typical.xml
new file mode 100644
index 0000000000000000000000000000000000000000..817bffb2568fee5e7097ac58fdfd091bac9bf350
--- /dev/null
+++ b/tests/resources/GP_Temperature_Typical.xml
@@ -0,0 +1,441 @@
+<?xml version="1.0" encoding="utf-8"?>
+<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcc="https://ptb.de/dcc" xmlns:si="https://ptb.de/si" xsi:schemaLocation="https://ptb.de/dcc https://ptb.de/dcc/v3.2.0/dcc.xsd" schemaVersion="3.2.0">
+    <dcc:administrativeData>
+        <dcc:dccSoftware>
+            <dcc:software>
+                <dcc:name>
+                    <dcc:content>Notepad++ (32-bit)</dcc:content>
+                </dcc:name>
+                <dcc:release>v 8.2</dcc:release>
+            </dcc:software>
+        </dcc:dccSoftware>
+        <dcc:coreData>
+            <dcc:countryCodeISO3166_1>DE</dcc:countryCodeISO3166_1>
+            <dcc:usedLangCodeISO639_1>en</dcc:usedLangCodeISO639_1>
+            <dcc:usedLangCodeISO639_1>de</dcc:usedLangCodeISO639_1>
+            <dcc:mandatoryLangCodeISO639_1>en</dcc:mandatoryLangCodeISO639_1>
+            <dcc:uniqueIdentifier>GP_DCC_temperature_typical_1.2</dcc:uniqueIdentifier>
+            <dcc:identifications>
+                <dcc:identification>
+                    <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                    <dcc:value>string-calibrationLaboratory-coreData</dcc:value>
+                    <dcc:name>
+                        <dcc:content lang="de">Auftrags Nr.</dcc:content>
+                        <dcc:content lang="en">Order no.</dcc:content>
+                    </dcc:name>
+                </dcc:identification>
+            </dcc:identifications>
+            <dcc:receiptDate>1957-08-13</dcc:receiptDate>
+            <dcc:beginPerformanceDate>1957-08-13</dcc:beginPerformanceDate>
+            <dcc:endPerformanceDate>1957-08-13</dcc:endPerformanceDate>
+            <dcc:performanceLocation>laboratory</dcc:performanceLocation>
+        </dcc:coreData>
+        <dcc:items>
+            <dcc:item>
+                <dcc:name>
+                    <dcc:content lang="de">Temperatur-Fühler</dcc:content>
+                    <dcc:content lang="en">Temperature sensor</dcc:content>
+                </dcc:name>
+                <dcc:manufacturer>
+                    <dcc:name>
+                        <dcc:content>String</dcc:content>
+                    </dcc:name>
+                </dcc:manufacturer>
+                <dcc:model>String</dcc:model>
+                <dcc:identifications>
+                    <dcc:identification>
+                        <dcc:issuer>manufacturer</dcc:issuer>
+                        <dcc:value>string-manufacturer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Serien Nr.</dcc:content>
+                            <dcc:content lang="en">Serial no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>customer</dcc:issuer>
+                        <dcc:value>string-customer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Messmittel Nr.</dcc:content>
+                            <dcc:content lang="en">Measurement equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                        <dcc:value>string-calibrationLaboratory-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Equipment Nr.</dcc:content>
+                            <dcc:content lang="en">Equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                </dcc:identifications>
+            </dcc:item>
+        </dcc:items>
+        <dcc:calibrationLaboratory>
+            <dcc:contact>
+                <dcc:name>
+                    <dcc:content>Kalibrierfirma GmbH</dcc:content>
+                </dcc:name>
+                <dcc:eMail>info@kalibrierfirma.xx</dcc:eMail>
+                <dcc:phone>+49 123 4567-89</dcc:phone>
+                <dcc:fax>+49 123 4567-90</dcc:fax>
+                <dcc:location>
+                    <dcc:city>Musterstadt</dcc:city>
+                    <dcc:countryCode>DE</dcc:countryCode>
+                    <dcc:postCode>00900</dcc:postCode>
+                    <dcc:street>Musterstraße</dcc:street>
+                    <dcc:streetNo>1</dcc:streetNo>
+                    <dcc:further>
+                        <dcc:content>www.kalibrierfirma.xx</dcc:content>
+                    </dcc:further>
+                </dcc:location>
+            </dcc:contact>
+        </dcc:calibrationLaboratory>
+        <dcc:respPersons>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michaela Musterfrau</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+                <dcc:mainSigner>true</dcc:mainSigner>
+            </dcc:respPerson>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michael Mustermann</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+            </dcc:respPerson>
+        </dcc:respPersons>
+        <dcc:customer>
+            <dcc:name>
+                <dcc:content>Kunde GmbH</dcc:content>
+            </dcc:name>
+            <dcc:eMail>info@kunde.xx</dcc:eMail>
+            <dcc:location>
+                <dcc:city>Musterstadt</dcc:city>
+                <dcc:countryCode>DE</dcc:countryCode>
+                <dcc:postCode>00900</dcc:postCode>
+                <dcc:further>
+                    <dcc:content lang="de">Kunden Nr. 1024418</dcc:content>
+                    <dcc:content lang="en">Customer ID no. 1024418</dcc:content>
+                </dcc:further>
+            </dcc:location>
+        </dcc:customer>
+        <dcc:statements>
+            <dcc:statement>
+                <dcc:norm>ISO/IEC 17025:2018-03</dcc:norm>
+                <dcc:reference>7.8.4.3</dcc:reference>
+                <dcc:declaration>
+                    <dcc:content lang="de">Die Ergebnisse gelten zum Zeitpunkt der Kalibrierung. Es obliegt dem Antragsteller, zu gegebener Zeit eine Rekalibrierung zu veranlassen.</dcc:content>
+                    <dcc:content lang="en">The results refer only to the object calibrated in this DCC. The measurement results are valid at the time of calibration. The applicant is responsible for arranging a recalibration in due time.</dcc:content>
+                </dcc:declaration>
+            </dcc:statement>
+            <dcc:statement refType="basic_validityRange">
+                <dcc:declaration>
+                    <dcc:content lang="de">Angabe des Temperaturbereichs, in dem kalibriert wurde:</dcc:content>
+                    <dcc:content lang="en">Specification of the temperature range in which calibration was performed:</dcc:content>
+                </dcc:declaration>
+                <dcc:data>
+                    <dcc:quantity refType="basic_validityRangeMin">
+                        <dcc:name>
+                            <dcc:content lang="de">Unteres Limit</dcc:content>
+                            <dcc:content lang="en">Lower limit</dcc:content>
+                        </dcc:name>
+                        <si:real>
+                            <si:value>306</si:value>
+                            <si:unit>\kelvin</si:unit>
+                        </si:real>
+                    </dcc:quantity>
+                    <dcc:quantity refType="basic_validityRangeMax">
+                        <dcc:name>
+                            <dcc:content lang="de">Oberes Limit</dcc:content>
+                            <dcc:content lang="en">Upper limit</dcc:content>
+                        </dcc:name>
+                        <si:real>
+                            <si:value>593</si:value>
+                            <si:unit>\kelvin</si:unit>
+                        </si:real>
+                    </dcc:quantity>
+                </dcc:data>
+            </dcc:statement>
+            <dcc:statement refType="basic_conformity">
+                <dcc:declaration>
+                    <dcc:content lang="de">Die Konformitätsaussage erfolgt anhand der Vorgaben des Kunden. Sie sind im DCC mit aufgeführt.</dcc:content>
+                    <dcc:content lang="en">The conformity statement is made on the basis of the customer's specifications. They are listed in the DCC.</dcc:content>
+                </dcc:declaration>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+                <dcc:conformity>pass</dcc:conformity>
+            </dcc:statement>
+            <dcc:statement refType="basic_recalibration">
+                <dcc:declaration>
+                    <dcc:content lang="de">Datum, wann nach der Festlegung durch den Kunden spätestens der Kalibriergegenstand rekalibriert werden soll:</dcc:content>
+                    <dcc:content lang="en">Date when the calibration item is to be recalibrated at the latest according to the customer's specification:</dcc:content>
+                </dcc:declaration>
+                <dcc:date>1959-10-22</dcc:date>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+            </dcc:statement>
+        </dcc:statements>
+    </dcc:administrativeData>
+    <dcc:measurementResults>
+        <dcc:measurementResult>
+            <dcc:name>
+                <dcc:content lang="de">Messergebnisse</dcc:content>
+                <dcc:content lang="en">Measurement results</dcc:content>
+            </dcc:name>
+            <dcc:usedMethods>
+                <dcc:usedMethod refType="basic_uncertainty">
+                    <dcc:name>
+                        <dcc:content lang="de">Erweiterte Messunsicherheit</dcc:content>
+                        <dcc:content lang="en">Expanded uncertainty</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Angegeben ist die erweiterte Messunsicherheit, die sich aus der Standardmessunsicherheit durch Multiplikation mit dem Erweiterungsfaktor k=2 ergibt. Sie wurde gemäß dem „Guide to the Expression of Uncertainty in Measurement (GUM)“ ermittelt. Der Wert der Messgröße liegt dann im Regelfall mit einer Wahrscheinlichkeit von annähernd 95 % im zugeordneten Überdeckungsintervall.</dcc:content>
+                        <dcc:content lang="en">The expanded uncertainty was calculated from the contributions of uncertainty originating from the standards used, from the weighings and the air buoyancy corrections. The reported uncertainty does not include an estimate of long-term variations.</dcc:content>
+                    </dcc:description>
+                    <dcc:norm>GUM</dcc:norm>
+                </dcc:usedMethod>
+                <dcc:usedMethod refType="gp_temperatureSensor">
+                    <dcc:name>
+                        <dcc:content lang="de">Kalibrierung von Temperaturmessfühlern</dcc:content>
+                        <dcc:content lang="en">Calibration of temperature sensors</dcc:content>
+                    </dcc:name>
+                    <dcc:norm>DKD-R 5-1:2018</dcc:norm>
+                </dcc:usedMethod>
+            </dcc:usedMethods>
+            <dcc:measuringEquipments>
+                <dcc:measuringEquipment refType="basic_normalUsed">
+                    <dcc:name>
+                        <dcc:content lang="de">Pt 100 Widerstandsthermometer</dcc:content>
+                        <dcc:content lang="en">Pt 100 thermometer</dcc:content>
+                    </dcc:name>
+                    <dcc:identifications>
+                        <dcc:identification>
+                            <dcc:issuer>manufacturer</dcc:issuer>
+                            <dcc:value>string-manufacturer-measuringEquipment-1</dcc:value>
+                        </dcc:identification>
+                    </dcc:identifications>
+                </dcc:measuringEquipment>
+            </dcc:measuringEquipments>
+            <dcc:influenceConditions>
+                <dcc:influenceCondition refType="gp_immersionDepth">
+                    <dcc:name>
+                        <dcc:content lang="de">Eintauchtiefe im Wasserbad</dcc:content>
+                        <dcc:content lang="en">Immersion depth in water bath</dcc:content>
+                    </dcc:name>
+                    <dcc:data>
+                        <dcc:quantity>
+                            <dcc:name>
+                                <dcc:content lang="de">Eintauchtiefe</dcc:content>
+                                <dcc:content lang="en">Immersion depth</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.1</si:value>
+                                <si:unit>\metre</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+                <dcc:influenceCondition refType="basic_temperature">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung Temperatur</dcc:content>
+                        <dcc:content lang="en">Ambient condition temperature</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_temperatureMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur min</dcc:content>
+                                <dcc:content lang="en">temperature min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>293</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_temperatureMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur max</dcc:content>
+                                <dcc:content lang="en">temperature max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>299</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+                <dcc:influenceCondition refType="basic_humidityRelative">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung relative Luftfeuchte</dcc:content>
+                        <dcc:content lang="en">Ambient condition relative humidity</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_humidityRelativeMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte min</dcc:content>
+                                <dcc:content lang="en">humidity min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.20</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_humidityRelativeMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte max</dcc:content>
+                                <dcc:content lang="en">humidity max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.70</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+            </dcc:influenceConditions>
+            <dcc:results>
+                <dcc:result refType="gp_measuringResult1">
+                    <dcc:name>
+                        <dcc:content lang="de">Messergebnisse</dcc:content>
+                        <dcc:content lang="en">Measuring results</dcc:content>
+                    </dcc:name>
+                    <dcc:data>
+                        <dcc:list refType="gp_table1">
+                            <dcc:quantity refType="basic_referenceValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Bezugswert</dcc:content>
+                                    <dcc:content lang="en">Reference value</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.098 99.971 175.103 250.169 320.004</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                                <dcc:measurementMetaData>
+                                    <dcc:metaData refType="basic_calibrationValue">
+                                        <dcc:declaration>
+                                            <dcc:content lang="de">Kalibrierpunkt</dcc:content>
+                                            <dcc:content lang="en">Calibration value</dcc:content>
+                                        </dcc:declaration>
+                                        <dcc:data>
+                                            <dcc:quantity>
+                                                <si:hybrid>
+                                                    <si:realListXMLList>
+                                                        <si:valueXMLList>306 373 448 523 593</si:valueXMLList>
+                                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                    </si:realListXMLList>
+                                                    <si:realListXMLList>
+                                                        <si:valueXMLList>32.85 99.85 174.85 249.85 319.85</si:valueXMLList>
+                                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                                    </si:realListXMLList>
+                                                </si:hybrid>
+                                            </dcc:quantity>
+                                        </dcc:data>
+                                    </dcc:metaData>
+                                </dcc:measurementMetaData>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measuredValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Angezeigter Messwert Kalibriergegenstand</dcc:content>
+                                    <dcc:content lang="en">Indicated measured value probe</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.32 373.21 448.36 523.31 593.07</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.17 100.06 175.21 250.16 319.92</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measurementError">
+                                <dcc:name>
+                                    <dcc:content lang="de">Messabweichung</dcc:content>
+                                    <dcc:content lang="en">Measurement error</dcc:content>
+                                </dcc:name>
+                                <si:realListXMLList>
+                                    <si:valueXMLList>0.072 0.089 0.107 -0.009 -0.084</si:valueXMLList>
+                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    <si:expandedUncXMLList>
+                                        <si:uncertaintyXMLList>0.061</si:uncertaintyXMLList>
+                                        <si:coverageFactorXMLList>2</si:coverageFactorXMLList>
+                                        <si:coverageProbabilityXMLList>0.95</si:coverageProbabilityXMLList>
+                                        <si:distributionXMLList>normal</si:distributionXMLList>
+                                    </si:expandedUncXMLList>
+                                </si:realListXMLList>
+                                <dcc:measurementMetaData>
+                                    <dcc:metaData refType="basic_conformity">
+                                        <dcc:declaration>
+                                            <dcc:name>
+                                                <dcc:content lang="de">Konformität</dcc:content>
+                                                <dcc:content lang="en">Conformity</dcc:content>
+                                            </dcc:name>
+                                        </dcc:declaration>
+                                        <dcc:conformityXMLList>pass</dcc:conformityXMLList>
+                                        <dcc:data>
+                                            <dcc:quantity refType="basic_acceptanceLimitLower">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Unteres Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Lower acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>-0.23 -0.23 -0.23 -0.30 -0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                            <dcc:quantity refType="basic_acceptanceLimitUpper">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Oberes Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Upper acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>0.23 0.23 0.23 0.30 0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                        </dcc:data>
+                                    </dcc:metaData>
+                                </dcc:measurementMetaData>
+                            </dcc:quantity>
+                        </dcc:list>
+                    </dcc:data>
+                </dcc:result>
+            </dcc:results>
+        </dcc:measurementResult>
+    </dcc:measurementResults>
+</dcc:digitalCalibrationCertificate>
\ No newline at end of file
diff --git a/tests/resources/GP_Temperature_v3.2.0_DCC.xml b/tests/resources/GP_Temperature_v3.2.0_DCC.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6cf833be84e22208a587a663cd0b0ed4f33d81ad
--- /dev/null
+++ b/tests/resources/GP_Temperature_v3.2.0_DCC.xml
@@ -0,0 +1,540 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcc="https://ptb.de/dcc" xmlns:si="https://ptb.de/si" xsi:schemaLocation="https://ptb.de/dcc https://ptb.de/dcc/v3.2.0/dcc.xsd" schemaVersion="3.2.0">
+    <dcc:administrativeData>
+        <dcc:dccSoftware>
+            <dcc:software>
+                <dcc:name>
+                    <dcc:content>Notepad++ (32-bit)</dcc:content>
+                </dcc:name>
+                <dcc:release>v 8.2</dcc:release>
+                <dcc:type>application</dcc:type>
+                <dcc:description>
+                    <dcc:name>
+                        <dcc:content>Open source text editor</dcc:content>
+                    </dcc:name>
+                    <dcc:content>https://notepad-plus-plus.org/downloads/</dcc:content>
+                </dcc:description>
+            </dcc:software>
+        </dcc:dccSoftware>
+        <dcc:refTypeDefinitions>
+            <dcc:refTypeDefinition>
+                <dcc:name>
+                    <dcc:content>Cross-Community refType Definition</dcc:content>
+                </dcc:name>
+                <dcc:description>
+                    <dcc:name>
+                        <dcc:content>Description name ABC</dcc:content>
+                    </dcc:name>
+                    <dcc:content>Description ABC</dcc:content>
+                </dcc:description>
+                <dcc:namespace>basic</dcc:namespace>
+                <dcc:link>https://www.ptb.de/dcc/refType/basic/draft_basic.xml</dcc:link>
+                <dcc:release>0.1</dcc:release>
+                <dcc:value>Value ABC</dcc:value>
+                <dcc:procedure>Procedure ABC</dcc:procedure>
+            </dcc:refTypeDefinition>
+        </dcc:refTypeDefinitions>
+        <dcc:coreData>
+            <dcc:countryCodeISO3166_1>DE</dcc:countryCodeISO3166_1>
+            <dcc:usedLangCodeISO639_1>en</dcc:usedLangCodeISO639_1>
+            <dcc:usedLangCodeISO639_1>de</dcc:usedLangCodeISO639_1>
+            <dcc:mandatoryLangCodeISO639_1>en</dcc:mandatoryLangCodeISO639_1>
+            <dcc:uniqueIdentifier>GP_DCC_temperature_minimal_1.1_Complete</dcc:uniqueIdentifier>
+            <dcc:identifications>
+                <dcc:identification>
+                    <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                    <dcc:value>string-calibrationLaboratory-coreData</dcc:value>
+                    <dcc:name>
+                        <dcc:content lang="de">Auftrags Nr.</dcc:content>
+                        <dcc:content lang="en">Order no.</dcc:content>
+                    </dcc:name>
+                </dcc:identification>
+            </dcc:identifications>
+            <dcc:receiptDate>1957-08-13</dcc:receiptDate>
+            <dcc:beginPerformanceDate>1957-08-13</dcc:beginPerformanceDate>
+            <dcc:endPerformanceDate>1957-08-13</dcc:endPerformanceDate>
+            <dcc:performanceLocation>laboratory</dcc:performanceLocation>
+            <dcc:issueDate>2022-12-31</dcc:issueDate>
+            <!-- TODO: dcc:previousReport -->
+        </dcc:coreData>
+        <dcc:items>
+            <dcc:item refType="test_items">
+                <dcc:name>
+                    <dcc:content lang="de">Temperatur-Fühler</dcc:content>
+                    <dcc:content lang="en">Temperature sensor</dcc:content>
+                </dcc:name>
+                <dcc:manufacturer>
+                    <dcc:name>
+                        <dcc:content>String</dcc:content>
+                    </dcc:name>
+                </dcc:manufacturer>
+                <dcc:model>String</dcc:model>
+                <dcc:identifications>
+                    <dcc:identification>
+                        <dcc:issuer>manufacturer</dcc:issuer>
+                        <dcc:value>string-manufacturer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Serien Nr.</dcc:content>
+                            <dcc:content lang="en">Serial no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>customer</dcc:issuer>
+                        <dcc:value>string-customer-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Messmittel Nr.</dcc:content>
+                            <dcc:content lang="en">Measurement equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                    <dcc:identification>
+                        <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                        <dcc:value>string-calibrationLaboratory-item</dcc:value>
+                        <dcc:name>
+                            <dcc:content lang="de">Equipment Nr.</dcc:content>
+                            <dcc:content lang="en">Equipment no.</dcc:content>
+                        </dcc:name>
+                    </dcc:identification>
+                </dcc:identifications>
+                <dcc:itemQuantities>
+                    <dcc:itemQuantity>
+                        <dcc:name>
+                            <dcc:content lang="de">Name der ItemQuantity</dcc:content>
+                            <dcc:content lang="en">Name of the item quantity</dcc:content>
+                        </dcc:name>
+                        <dcc:description>
+                            <dcc:content>Membrandurchmesser</dcc:content>
+                        </dcc:description>
+                        <si:real>
+                            <si:value>0.05</si:value>
+                            <si:unit>\metre</si:unit>
+                        </si:real>
+                    </dcc:itemQuantity>
+                    <dcc:itemQuantity>
+                        <dcc:description>
+                            <dcc:content>Membranstärke</dcc:content>
+                        </dcc:description>
+                        <si:real>
+                            <si:value>0.0003</si:value>
+                            <si:unit>\metre</si:unit>
+                        </si:real>
+                    </dcc:itemQuantity>
+                </dcc:itemQuantities>
+            </dcc:item>
+        </dcc:items>
+        <dcc:calibrationLaboratory>
+            <dcc:contact>
+                <dcc:name>
+                    <dcc:content>Kalibrierfirma GmbH</dcc:content>
+                </dcc:name>
+                <dcc:eMail>info@kalibrierfirma.xx</dcc:eMail>
+                <dcc:phone>+49 123 4567-89</dcc:phone>
+                <dcc:fax>+49 123 4567-90</dcc:fax>
+                <dcc:location>
+                    <dcc:city>Musterstadt</dcc:city>
+                    <dcc:countryCode>DE</dcc:countryCode>
+                    <dcc:postCode>00900</dcc:postCode>
+                    <dcc:street>Musterstraße</dcc:street>
+                    <dcc:streetNo>1</dcc:streetNo>
+                    <dcc:further>
+                        <dcc:content>www.kalibrierfirma.xx</dcc:content>
+                    </dcc:further>
+                </dcc:location>
+            </dcc:contact>
+            <dcc:cryptElectronicSeal>true</dcc:cryptElectronicSeal>
+            <dcc:cryptElectronicSignature>false</dcc:cryptElectronicSignature>
+            <dcc:cryptElectronicTimeStamp>true</dcc:cryptElectronicTimeStamp>
+        </dcc:calibrationLaboratory>
+        <dcc:respPersons>
+            <dcc:respPerson refType="test_respPerson">
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michaela Musterfrau</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+                <dcc:mainSigner>true</dcc:mainSigner>
+            </dcc:respPerson>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michael Mustermann</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+            </dcc:respPerson>
+        </dcc:respPersons>
+        <dcc:customer>
+            <dcc:name>
+                <dcc:content>Kunde GmbH</dcc:content>
+            </dcc:name>
+            <dcc:eMail>info@kunde.xx</dcc:eMail>
+            <dcc:location>
+                <dcc:city>Musterstadt</dcc:city>
+                <dcc:countryCode>DE</dcc:countryCode>
+                <dcc:postCode>00900</dcc:postCode>
+                <dcc:further>
+                    <dcc:content lang="de">Kunden Nr. 1024418</dcc:content>
+                    <dcc:content lang="en">Customer ID no. 1024418</dcc:content>
+                </dcc:further>
+            </dcc:location>
+        </dcc:customer>
+        <dcc:statements>
+            <dcc:statement refType="basic_conformity">
+                <dcc:name>
+                    <dcc:content lang="de">Name der Konformitätsaussage</dcc:content>
+                    <dcc:content lang="en">Name of conformity statement</dcc:content>
+                </dcc:name>
+                <dcc:description>
+                    <dcc:content lang="de">Beschreibung der Konformitätsaussage</dcc:content>
+                    <dcc:content lang="en">Description of conformity statement</dcc:content>
+                </dcc:description>
+                <dcc:declaration>
+                    <dcc:content lang="de">Die Konformitätsaussage erfolgt anhand der Vorgaben des Kunden. Sie sind im DCC mit aufgeführt.</dcc:content>
+                    <dcc:content lang="en">The conformity statement is made on the basis of the customer's specifications. They are listed in the DCC.</dcc:content>
+                </dcc:declaration>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+                <dcc:conformity>pass</dcc:conformity>
+                <dcc:data>
+                    <dcc:quantity>
+                        <dcc:name>
+                            <dcc:content lang="de">Ãœbertragungskoeffizient Phasenverschiebung</dcc:content>
+                            <dcc:content lang="en">en</dcc:content>
+                        </dcc:name>
+                        <si:realListXMLList>
+                            <si:valueXMLList>-0.02 -0.03 -0.02 -0.02 -0.01</si:valueXMLList>
+                            <si:unitXMLList>\degree</si:unitXMLList>
+                            <si:expandedUncXMLList>
+                                <si:uncertaintyXMLList>0.3 0.3 0.3 0.3 0.3</si:uncertaintyXMLList>
+                                <si:coverageFactorXMLList>2</si:coverageFactorXMLList>
+                                <si:coverageProbabilityXMLList>0.95</si:coverageProbabilityXMLList>
+                                <si:distributionXMLList>normal</si:distributionXMLList>
+                            </si:expandedUncXMLList>
+                        </si:realListXMLList>
+                        <dcc:measurementMetaData>
+                            <dcc:metaData>
+                                <dcc:declaration>
+                                    <dcc:content lang="de">Kommentar ist gültig für den dritten Eintrag.</dcc:content>
+                                </dcc:declaration>
+                                <dcc:validXMLList>false false true false false</dcc:validXMLList>
+                            </dcc:metaData>
+                        </dcc:measurementMetaData>
+                    </dcc:quantity>
+                </dcc:data>
+            </dcc:statement>
+            <dcc:statement refType="basic_recalibration">
+                <dcc:declaration>
+                    <dcc:content lang="de">Datum, wann nach der Festlegung durch den Kunden spätestens der Kalibriergegenstand rekalibriert werden soll:</dcc:content>
+                    <dcc:content lang="en">Date when the calibration item is to be recalibrated at the latest according to the customer's specification:</dcc:content>
+                </dcc:declaration>
+                <dcc:date>1959-10-22</dcc:date>
+                <dcc:respAuthority>
+                    <dcc:name>
+                        <dcc:content>Kunde GmbH</dcc:content>
+                    </dcc:name>
+                    <dcc:eMail>info@kunde.xx</dcc:eMail>
+                    <dcc:location>
+                        <dcc:city>Musterstadt</dcc:city>
+                        <dcc:countryCode>DE</dcc:countryCode>
+                        <dcc:postCode>00900</dcc:postCode>
+                    </dcc:location>
+                </dcc:respAuthority>
+            </dcc:statement>
+        </dcc:statements>
+    </dcc:administrativeData>
+    <dcc:measurementResults>
+        <dcc:measurementResult>
+            <dcc:name>
+                <dcc:content lang="de">Messergebnisse</dcc:content>
+                <dcc:content lang="en">Measurement results</dcc:content>
+            </dcc:name>
+            <dcc:usedMethods>
+                <dcc:usedMethod refType="gp_temperatureSensor">
+                    <dcc:name>
+                        <dcc:content lang="de">Kalibrierung von Temperaturmessfühlern</dcc:content>
+                        <dcc:content lang="en">Calibration of temperature sensors</dcc:content>
+                    </dcc:name>
+                </dcc:usedMethod>
+            </dcc:usedMethods>
+            <dcc:measuringEquipments>
+                <dcc:measuringEquipment refType="basic_normalUsed">
+                    <dcc:name>
+                        <dcc:content lang="de">Pt 100 Widerstandsthermometer</dcc:content>
+                        <dcc:content lang="en">Pt 100 thermometer</dcc:content>
+                    </dcc:name>
+                    <dcc:identifications>
+                        <dcc:identification>
+                            <dcc:issuer>manufacturer</dcc:issuer>
+                            <dcc:value>string-manufacturer-measuringEquipment-1</dcc:value>
+                        </dcc:identification>
+                    </dcc:identifications>
+                </dcc:measuringEquipment>
+            </dcc:measuringEquipments>
+            <dcc:influenceConditions>
+                <dcc:influenceCondition refType="basic_temperature">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung Temperatur</dcc:content>
+                        <dcc:content lang="en">Ambient condition temperature</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_temperatureMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur min</dcc:content>
+                                <dcc:content lang="en">temperature min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>293</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_temperatureMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Temperatur max</dcc:content>
+                                <dcc:content lang="en">temperature max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>299</si:value>
+                                <si:unit>\kelvin</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+                <dcc:influenceCondition refType="basic_humidityRelative">
+                    <dcc:name>
+                        <dcc:content lang="de">Umgebungsbedingung relative Luftfeuchte</dcc:content>
+                        <dcc:content lang="en">Ambient condition relative humidity</dcc:content>
+                    </dcc:name>
+                    <dcc:description>
+                        <dcc:content lang="de">Diese Werte wurden nicht gemessen, sondern wurden anhand der typischen Wetterbedingungen zu einer Jahreszeit angegeben. [^1]</dcc:content>
+                        <dcc:content lang="en">These values were not measured, but were given based on typical weather conditions at a time of year. [^1]</dcc:content>
+                    </dcc:description>
+                    <dcc:data>
+                        <dcc:quantity refType="basic_humidityRelativeMin">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte min</dcc:content>
+                                <dcc:content lang="en">humidity min</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.20</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="basic_humidityRelativeMax">
+                            <dcc:name>
+                                <dcc:content lang="de">Feuchte max</dcc:content>
+                                <dcc:content lang="en">humidity max</dcc:content>
+                            </dcc:name>
+                            <si:real>
+                                <si:value>0.70</si:value>
+                                <si:unit>\one</si:unit>
+                            </si:real>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:influenceCondition>
+            </dcc:influenceConditions>
+            <dcc:results>
+                <dcc:result refType="gp_measuringResult1">
+                    <dcc:name>
+                        <dcc:content lang="de">Messergebnisse</dcc:content>
+                        <dcc:content lang="en">Measuring results</dcc:content>
+                    </dcc:name>
+                    <dcc:data>
+                        <dcc:list refType="gp_table1">
+                            <dcc:quantity refType="basic_referenceValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Bezugswert</dcc:content>
+                                    <dcc:content lang="en">Reference value</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.098 99.971 175.103 250.169 320.004</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measuredValue">
+                                <dcc:name>
+                                    <dcc:content lang="de">Angezeigter Messwert Kalibriergegenstand</dcc:content>
+                                    <dcc:content lang="en">Indicated measured value probe</dcc:content>
+                                </dcc:name>
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.32 373.21 448.36 523.31 593.07</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.17 100.06 175.21 250.16 319.92</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                            <dcc:quantity refType="basic_measurementError">
+                                <dcc:name>
+                                    <dcc:content lang="de">Messabweichung</dcc:content>
+                                    <dcc:content lang="en">Measurement error</dcc:content>
+                                </dcc:name>
+                                <si:realListXMLList>
+                                    <si:valueXMLList>0.072 0.089 0.107 -0.009 -0.084</si:valueXMLList>
+                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    <si:expandedUncXMLList>
+                                        <si:uncertaintyXMLList>0.061</si:uncertaintyXMLList>
+                                        <si:coverageFactorXMLList>2</si:coverageFactorXMLList>
+                                        <si:coverageProbabilityXMLList>0.95</si:coverageProbabilityXMLList>
+                                        <si:distributionXMLList>normal</si:distributionXMLList>
+                                    </si:expandedUncXMLList>
+                                </si:realListXMLList>
+                                <dcc:measurementMetaData>
+                                    <dcc:metaData refType="basic_conformity">
+                                        <dcc:name>
+                                            <dcc:content lang="de">Metadaten 1</dcc:content>
+                                            <dcc:content lang="en">Meta data 1</dcc:content>
+                                        </dcc:name>
+                                        <dcc:description>
+                                            <dcc:content lang="de">Beschreibung der Metadaten 1</dcc:content>
+                                            <dcc:content lang="en">Description of Meta data 1</dcc:content>
+                                        </dcc:description>
+                                        <dcc:declaration>
+                                            <dcc:name>
+                                                <dcc:content lang="de">Konformität</dcc:content>
+                                                <dcc:content lang="en">Conformity</dcc:content>
+                                            </dcc:name>
+                                        </dcc:declaration>
+                                        <dcc:conformityXMLList>pass</dcc:conformityXMLList>
+                                        <dcc:data>
+                                            <dcc:quantity refType="basic_acceptanceLimitLower">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Unteres Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Lower acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>-0.23 -0.23 -0.23 -0.30 -0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                            <dcc:quantity refType="basic_acceptanceLimitUpper">
+                                                <dcc:name>
+                                                    <dcc:content lang="de">Oberes Akzeptanzlimit</dcc:content>
+                                                    <dcc:content lang="en">Upper acceptance limit</dcc:content>
+                                                </dcc:name>
+                                                <si:realListXMLList>
+                                                    <si:valueXMLList>0.23 0.23 0.23 0.30 0.30</si:valueXMLList>
+                                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                                </si:realListXMLList>
+                                            </dcc:quantity>
+                                        </dcc:data>
+                                    </dcc:metaData>
+                                </dcc:measurementMetaData>
+                            </dcc:quantity>
+                        </dcc:list>
+                        <dcc:quantity refType="test_noQuantity">
+                            <dcc:noQuantity>
+                                <dcc:name>
+                                    <dcc:content>Example name</dcc:content>
+                                </dcc:name>
+                                <dcc:content>Example text</dcc:content>
+                                <dcc:file refType="examplePicture">
+                                    <dcc:fileName>examplePicture.png</dcc:fileName>
+                                    <dcc:mimeType>image/png</dcc:mimeType>
+                                    <dcc:dataBase64>iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAEDmlDQ1BrQ0dDb2xvclNwYWNlR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRBkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4a73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PCv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UAVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXda8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8HOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojLjVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0yDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5PtXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEwQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXHliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vWc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUtVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJfcl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdduwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqvgcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCgKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8ArD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvFY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAAAUoAMABAAAAAEAAAAUAAAAAJEV0scAAAAtSURBVDgRY2RgYPgPxFQDTFQzCWrQqIGUh+hoGI6GIRkhMJpsyAg0NC0jMAwBzu4BJ2FWhpgAAAAASUVORK5CYII=</dcc:dataBase64>
+                                </dcc:file>
+                                <dcc:formula>
+                                    <dcc:latex>E = mc^2</dcc:latex>
+                                </dcc:formula>
+                            </dcc:noQuantity>
+                        </dcc:quantity>
+                        <dcc:quantity refType="test_charsXMLList">
+                            <dcc:charsXMLList>A B C D E F</dcc:charsXMLList>
+                        </dcc:quantity>
+                        <dcc:quantity refType="test_constant">
+                            <si:constant>
+                                <si:label>exampleLabel</si:label>
+                                <si:value>306.248</si:value>
+                                <si:unit>\kelvin</si:unit>
+                                <si:dateTime>1111-11-11T11:11:11</si:dateTime>
+                            </si:constant>
+                        </dcc:quantity>
+                        <dcc:quantity refType="test_real">
+                            <si:real>
+                                <si:label>exampleLabel</si:label>
+                                <si:value>306.248</si:value>
+                                <si:unit>\kelvin</si:unit>
+                                <si:dateTime>1111-11-11T11:11:11</si:dateTime>
+                            </si:real>
+                        </dcc:quantity>
+                        <dcc:quantity refType="test_realListXMLList">
+                            <si:realListXMLList>
+                                <si:labelXMLList>exampleLabel</si:labelXMLList>
+                                <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
+                                <si:unitXMLList>\kelvin</si:unitXMLList>
+                                <si:dateTimeXMLList>1111-11-11T11:11:11 1111-11-11T11:11:12 1111-11-11T11:11:13 1111-11-11T11:11:14 1111-11-11T11:11:15</si:dateTimeXMLList>
+                            </si:realListXMLList>
+                        </dcc:quantity>
+                        <dcc:quantity refType="test_hybridConstant">
+                            <si:hybrid>
+                                <si:constant>
+                                    <si:label>exampleLabel</si:label>
+                                    <si:value>306.248</si:value>
+                                    <si:unit>\kelvin</si:unit>
+                                    <si:dateTime>1111-11-11T11:11:11</si:dateTime>
+                                </si:constant>
+                                <si:constant>
+                                    <si:label>exampleLabel</si:label>
+                                    <si:value>33.098</si:value>
+                                    <si:unit>\degreecelsius</si:unit>
+                                    <si:dateTime>1111-11-11T11:11:11</si:dateTime>
+                                </si:constant>
+                            </si:hybrid>
+                        </dcc:quantity>
+                        <dcc:quantity refType="test_hybridReal">
+                            <si:hybrid>
+                                <si:real>
+                                    <si:label>exampleLabel</si:label>
+                                    <si:value>306.248</si:value>
+                                    <si:unit>\kelvin</si:unit>
+                                    <si:dateTime>1111-11-11T11:11:11</si:dateTime>
+                                </si:real>
+                                <si:real>
+                                    <si:label>exampleLabel</si:label>
+                                    <si:value>33.098</si:value>
+                                    <si:unit>\degreecelsius</si:unit>
+                                    <si:dateTime>1111-11-11T11:11:11</si:dateTime>
+                                </si:real>
+                            </si:hybrid>
+                        </dcc:quantity>
+                        <dcc:quantity refType="test_hybridRealListXMLList">
+                            <si:hybrid>
+                                <si:realListXMLList>
+                                    <si:labelXMLList>exampleLabel</si:labelXMLList>
+                                    <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
+                                    <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    <si:dateTimeXMLList>1111-11-11T11:11:11 1111-11-11T11:11:12 1111-11-11T11:11:13 1111-11-11T11:11:14 1111-11-11T11:11:15</si:dateTimeXMLList>
+                                </si:realListXMLList>
+                                <si:realListXMLList>
+                                    <si:labelXMLList>exampleLabel</si:labelXMLList>
+                                    <si:valueXMLList>33.098 99.971 175.103 250.169 320.004</si:valueXMLList>
+                                    <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    <si:dateTimeXMLList>1111-11-11T11:11:11 1111-11-11T11:11:12 1111-11-11T11:11:13 1111-11-11T11:11:14 1111-11-11T11:11:15</si:dateTimeXMLList>
+                                </si:realListXMLList>
+                            </si:hybrid>
+                        </dcc:quantity>
+                    </dcc:data>
+                </dcc:result>
+            </dcc:results>
+        </dcc:measurementResult>
+    </dcc:measurementResults>
+</dcc:digitalCalibrationCertificate>
\ No newline at end of file
diff --git a/tests/resources/Test_DCC_Minimal.xml b/tests/resources/Test_DCC_Minimal.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7707aa19a334198adad229cdebc8525a945b3dae
--- /dev/null
+++ b/tests/resources/Test_DCC_Minimal.xml
@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="utf-8"?>
+<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcc="https://ptb.de/dcc" xmlns:si="https://ptb.de/si" xsi:schemaLocation="https://ptb.de/dcc https://ptb.de/dcc/v3.2.0/dcc.xsd" schemaVersion="3.2.0">
+    <dcc:administrativeData>
+        <dcc:dccSoftware>
+            <dcc:software>
+                <dcc:name>
+                    <dcc:content>Notepad++ (32-bit)</dcc:content>
+                </dcc:name>
+                <dcc:release>v 8.2</dcc:release>
+            </dcc:software>
+        </dcc:dccSoftware>
+        <dcc:coreData>
+            <dcc:countryCodeISO3166_1>DE</dcc:countryCodeISO3166_1>
+            <dcc:usedLangCodeISO639_1>en</dcc:usedLangCodeISO639_1>
+            <dcc:mandatoryLangCodeISO639_1>en</dcc:mandatoryLangCodeISO639_1>
+            <dcc:uniqueIdentifier>Test_DCC_Minimal</dcc:uniqueIdentifier>
+            <dcc:identifications>
+                <dcc:identification>
+                    <dcc:issuer>calibrationLaboratory</dcc:issuer>
+                    <dcc:value>string-calibrationLaboratory-coreData</dcc:value>
+                    <dcc:name>
+                        <dcc:content lang="en">Order no.</dcc:content>
+                    </dcc:name>
+                </dcc:identification>
+            </dcc:identifications>
+            <dcc:beginPerformanceDate>1957-08-13</dcc:beginPerformanceDate>
+            <dcc:endPerformanceDate>1957-08-13</dcc:endPerformanceDate>
+            <dcc:performanceLocation>laboratory</dcc:performanceLocation>
+        </dcc:coreData>
+        <dcc:items>
+            <dcc:item>
+                <dcc:name>
+                    <dcc:content lang="de">Temperatur-Fühler</dcc:content>
+                    <dcc:content lang="en">Temperature sensor</dcc:content>
+                </dcc:name>
+                <dcc:manufacturer>
+                    <dcc:name>
+                        <dcc:content>String</dcc:content>
+                    </dcc:name>
+                </dcc:manufacturer>
+                <dcc:identifications>
+                    <dcc:identification>
+                        <dcc:issuer>manufacturer</dcc:issuer>
+                        <dcc:value>string-manufacturer-item</dcc:value>
+                    </dcc:identification>
+                </dcc:identifications>
+            </dcc:item>
+        </dcc:items>
+        <dcc:calibrationLaboratory>
+            <dcc:contact>
+                <dcc:name>
+                    <dcc:content>Kalibrierfirma GmbH</dcc:content>
+                </dcc:name>
+                <dcc:location>
+                    <dcc:city>Musterstadt</dcc:city>
+                </dcc:location>
+            </dcc:contact>
+        </dcc:calibrationLaboratory>
+        <dcc:respPersons>
+            <dcc:respPerson>
+                <dcc:person>
+                    <dcc:name>
+                        <dcc:content>Michaela Musterfrau</dcc:content>
+                    </dcc:name>
+                </dcc:person>
+            </dcc:respPerson>
+        </dcc:respPersons>
+        <dcc:customer>
+            <dcc:name>
+                <dcc:content>Kunde GmbH</dcc:content>
+            </dcc:name>
+            <dcc:location>
+                <dcc:city>Musterstadt</dcc:city>
+            </dcc:location>
+        </dcc:customer>
+    </dcc:administrativeData>
+    <dcc:measurementResults>
+        <dcc:measurementResult>
+            <dcc:name>
+                <dcc:content lang="en">Measurement results</dcc:content>
+            </dcc:name>
+            <dcc:results>
+                <dcc:result refType="gp_measuringResult1">
+                    <dcc:name>
+                        <dcc:content lang="de">Messergebnisse</dcc:content>
+                        <dcc:content lang="en">Measuring results</dcc:content>
+                    </dcc:name>
+                    <dcc:data>
+                        <dcc:list refType="gp_table1">
+                            <dcc:quantity refType="basic_referenceValue">
+                                <si:hybrid>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
+                                        <si:unitXMLList>\kelvin</si:unitXMLList>
+                                    </si:realListXMLList>
+                                    <si:realListXMLList>
+                                        <si:valueXMLList>33.098 99.971 175.103 250.169 320.004</si:valueXMLList>
+                                        <si:unitXMLList>\degreecelsius</si:unitXMLList>
+                                    </si:realListXMLList>
+                                </si:hybrid>
+                            </dcc:quantity>
+                        </dcc:list>
+                    </dcc:data>
+                </dcc:result>
+            </dcc:results>
+        </dcc:measurementResult>
+    </dcc:measurementResults>
+</dcc:digitalCalibrationCertificate>
\ No newline at end of file
diff --git a/tests/Resources/example.xml.ts b/tests/resources/example.xml
similarity index 93%
rename from tests/Resources/example.xml.ts
rename to tests/resources/example.xml
index 5bacaeff1cac3427e1bf8d2eace3c68f935185e9..e4dec5e45f21e40157ddca30566c678fe10d8116 100644
--- a/tests/Resources/example.xml.ts
+++ b/tests/resources/example.xml
@@ -1,4 +1,5 @@
-const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcc="https://ptb.de/dcc" xmlns:si="https://ptb.de/si" xsi:schemaLocation="https://ptb.de/dcc https://ptb.de/dcc/v3.1.2/dcc.xsd" schemaVersion="3.1.2">
+<?xml version="1.0" encoding="UTF-8"?>
+<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dcc="https://ptb.de/dcc" xmlns:si="https://ptb.de/si" xsi:schemaLocation="https://ptb.de/dcc https://ptb.de/dcc/v3.2.0/dcc.xsd" schemaVersion="3.2.0">
   <dcc:administrativeData>
     <dcc:dccSoftware>
       <dcc:software>
@@ -143,7 +144,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
             </dcc:name>
             <si:real>
               <si:value>306</si:value>
-              <si:unit>\\kelvin</si:unit>
+              <si:unit>\kelvin</si:unit>
             </si:real>
           </dcc:quantity>
           <dcc:quantity refType="basic_validityRangeMax">
@@ -153,7 +154,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
             </dcc:name>
             <si:real>
               <si:value>593</si:value>
-              <si:unit>\\kelvin</si:unit>
+              <si:unit>\kelvin</si:unit>
             </si:real>
           </dcc:quantity>
         </dcc:data>
@@ -250,7 +251,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
               </dcc:name>
               <si:real>
                 <si:value>0.1</si:value>
-                <si:unit>\\metre</si:unit>
+                <si:unit>\metre</si:unit>
               </si:real>
             </dcc:quantity>
           </dcc:data>
@@ -272,7 +273,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
               </dcc:name>
               <si:real>
                 <si:value>293</si:value>
-                <si:unit>\\kelvin</si:unit>
+                <si:unit>\kelvin</si:unit>
               </si:real>
             </dcc:quantity>
             <dcc:quantity refType="basic_temperatureMax">
@@ -282,7 +283,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
               </dcc:name>
               <si:real>
                 <si:value>299</si:value>
-                <si:unit>\\kelvin</si:unit>
+                <si:unit>\kelvin</si:unit>
               </si:real>
             </dcc:quantity>
           </dcc:data>
@@ -304,7 +305,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
               </dcc:name>
               <si:real>
                 <si:value>0.20</si:value>
-                <si:unit>\\one</si:unit>
+                <si:unit>\one</si:unit>
               </si:real>
             </dcc:quantity>
             <dcc:quantity refType="basic_humidityRelativeMax">
@@ -314,7 +315,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
               </dcc:name>
               <si:real>
                 <si:value>0.70</si:value>
-                <si:unit>\\one</si:unit>
+                <si:unit>\one</si:unit>
               </si:real>
             </dcc:quantity>
           </dcc:data>
@@ -336,11 +337,11 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
                 <si:hybrid>
                   <si:realListXMLList>
                     <si:valueXMLList>306.248 373.121 448.253 523.319 593.154</si:valueXMLList>
-                    <si:unitXMLList>\\kelvin</si:unitXMLList>
+                    <si:unitXMLList>\kelvin</si:unitXMLList>
                   </si:realListXMLList>
                   <si:realListXMLList>
                     <si:valueXMLList>33.098 99.971 175.103 250.169 320.004</si:valueXMLList>
-                    <si:unitXMLList>\\degreecelsius</si:unitXMLList>
+                    <si:unitXMLList>\degreecelsius</si:unitXMLList>
                   </si:realListXMLList>
                 </si:hybrid>
                 <dcc:measurementMetaData>
@@ -354,11 +355,11 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
                         <si:hybrid>
                           <si:realListXMLList>
                             <si:valueXMLList>306 373 448 523 593</si:valueXMLList>
-                            <si:unitXMLList>\\kelvin</si:unitXMLList>
+                            <si:unitXMLList>\kelvin</si:unitXMLList>
                           </si:realListXMLList>
                           <si:realListXMLList>
                             <si:valueXMLList>32.85 99.85 174.85 249.85 319.85</si:valueXMLList>
-                            <si:unitXMLList>\\degreecelsius</si:unitXMLList>
+                            <si:unitXMLList>\degreecelsius</si:unitXMLList>
                           </si:realListXMLList>
                         </si:hybrid>
                       </dcc:quantity>
@@ -374,11 +375,11 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
                 <si:hybrid>
                   <si:realListXMLList>
                     <si:valueXMLList>306.32 373.21 448.36 523.31 593.07</si:valueXMLList>
-                    <si:unitXMLList>\\kelvin</si:unitXMLList>
+                    <si:unitXMLList>\kelvin</si:unitXMLList>
                   </si:realListXMLList>
                   <si:realListXMLList>
                     <si:valueXMLList>33.17 100.06 175.21 250.16 319.92</si:valueXMLList>
-                    <si:unitXMLList>\\degreecelsius</si:unitXMLList>
+                    <si:unitXMLList>\degreecelsius</si:unitXMLList>
                   </si:realListXMLList>
                 </si:hybrid>
               </dcc:quantity>
@@ -389,7 +390,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
                 </dcc:name>
                 <si:realListXMLList>
                   <si:valueXMLList>0.072 0.089 0.107 -0.009 -0.084</si:valueXMLList>
-                  <si:unitXMLList>\\kelvin</si:unitXMLList>
+                  <si:unitXMLList>\kelvin</si:unitXMLList>
                   <si:expandedUncXMLList>
                     <si:uncertaintyXMLList>0.061</si:uncertaintyXMLList>
                     <si:coverageFactorXMLList>2</si:coverageFactorXMLList>
@@ -414,7 +415,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
                         </dcc:name>
                         <si:realListXMLList>
                           <si:valueXMLList>-0.23 -0.23 -0.23 -0.30 -0.30</si:valueXMLList>
-                          <si:unitXMLList>\\kelvin</si:unitXMLList>
+                          <si:unitXMLList>\kelvin</si:unitXMLList>
                         </si:realListXMLList>
                       </dcc:quantity>
                       <dcc:quantity refType="basic_acceptanceLimitUpper">
@@ -424,7 +425,7 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
                         </dcc:name>
                         <si:realListXMLList>
                           <si:valueXMLList>0.23 0.23 0.23 0.30 0.30</si:valueXMLList>
-                          <si:unitXMLList>\\kelvin</si:unitXMLList>
+                          <si:unitXMLList>\kelvin</si:unitXMLList>
                         </si:realListXMLList>
                       </dcc:quantity>
                     </dcc:data>
@@ -437,7 +438,4 @@ const dcc = `<dcc:digitalCalibrationCertificate xmlns:xsi="http://www.w3.org/200
       </dcc:results>
     </dcc:measurementResult>
   </dcc:measurementResults>
-</dcc:digitalCalibrationCertificate>`;
-
-export const xml = `<?xml version="1.0" encoding="UTF-8"?>
-${dcc}`;
+</dcc:digitalCalibrationCertificate>
\ No newline at end of file
diff --git a/tests/tsconfig.json b/tests/tsconfig.json
new file mode 100644
index 0000000000000000000000000000000000000000..6ddab7ad84a0055407b85634ffba8270cd7781e5
--- /dev/null
+++ b/tests/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "declaration": true,
+    "module": "commonjs"
+  },
+}
diff --git a/tests/util.ts b/tests/util.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cbabf5da7ba3e3700e7de1f2c6917190349feef0
--- /dev/null
+++ b/tests/util.ts
@@ -0,0 +1,36 @@
+import * as xpathTs from "xpath-ts";
+import { JSDOM } from "jsdom";
+import { DCCDocument, DCCXMLElement } from "../src";
+
+export function select(xpath: string, domOrDCC: JSDOM | DCCDocument): string | number | boolean | Node | Node[] {
+  let dom = <JSDOM>domOrDCC;
+  if (domOrDCC.digitalCalibrationCertificate) {
+    dom = toDom(<DCCDocument>domOrDCC);
+  }
+
+  return xpathTs.select(xpath, dom.window.document);
+}
+
+export function toDom(dcc: DCCDocument) {
+  return new JSDOM(dcc.toXML(), { contentType: "application/xml" });
+}
+
+export function toTextArr(arr: DCCXMLElement[]) {
+  if (!arr) return [];
+  return arr.map((x) => x._text);
+}
+
+export function indexOf(arr: DCCXMLElement[], el: string) {
+  return toTextArr(arr).indexOf(el);
+}
+
+export function toTextContentArr(el: Element[]) {
+  if (!el) return [];
+  return el.map((x) => x.textContent);
+}
+
+export function undefinedIfEmpty(str) {
+  if (!str) return undefined;
+  if (str.trim() === "") return undefined;
+  return str;
+}
diff --git a/tsconfig.json b/tsconfig.json
index b736aad68b571c6a63f43887212ab3edba93a63b..5136c1bfd74e88b9abfd0e55735dd398ad833483 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,8 +3,12 @@
     "target": "ES6",
     "module": "commonjs",
     "declaration": true,
-    "outDir": "./lib"
+    "sourceMap": true,
+    "outDir": "./lib",
   },
+  "files": [
+    "./tests/index.d.ts"
+  ],
   "include": [
     "src"
   ],
diff --git a/yarn.lock b/yarn.lock
new file mode 100644
index 0000000000000000000000000000000000000000..85098f5a364c9ba6a2170cbd50db5b8a977f019b
Binary files /dev/null and b/yarn.lock differ