Make the closure dedup and feature sort tests discriminating

Both behaviours survived a mutation of the implementation. Add a closure
fixture that repeats a pair and reports a self-pair, and run the feature
sort test under a collation that disagrees with byte order - testthat
forces LC_COLLATE=C, where the two sorts are indistinguishable.

Author: johngrimes

r/DESCRIPTION

@@ -28,7 +28,8 @@ Suggests:
     jsonlite,
     recipes,
     testthat (>= 3.0.0),
-    tibble
+    tibble,
+    withr
 Config/testthat/edition: 3
 Encoding: UTF-8
 Config/roxygen2/version: 8.1.0

r/tests/testthat/fixtures/README.md

@@ -93,6 +93,7 @@ it contributes no feature - only its subproperties do.
 | `closure-update-batch-1.json` | New pairs from adding concepts 1-4 only (6 pairs), for use with the two-page expansion. |
 | `closure-update-batch-2.json` | New pairs from then adding concepts 5-6 (9 pairs). Batches 1 and 2 together give the same 15 pairs as `closure-update.json`. |
 | `closure-update-no-group.json` | An update response with no `group` at all, which must contribute zero pairs. |
+| `closure-update-duplicates.json` | Reports the pair `(399981008, 404684003)` three times - twice in one group, once in a second - and reports `363346000` as subsuming itself, colliding with the identity cell. The encoding must stay multi-hot, so both cells must be exactly 1. `Matrix::sparseMatrix()` sums duplicate triplets, so this is what catches a missing deduplication step. |
 
 ### Pair orientation
 

r/tests/testthat/fixtures/closure-update-duplicates.json

@@ -0,0 +1,57 @@
+{
+  "resourceType": "ConceptMap",
+  "version": "2",
+  "name": "6c1e9a0b3f5d47a2b8e0c4d19f7a2b3c",
+  "status": "active",
+  "experimental": false,
+  "date": "2026-08-15T20:29:01+10:00",
+  "group": [
+    {
+      "source": "http://snomed.info/sct",
+      "sourceVersion": "http://snomed.info/sct/32506021000036107/version/20260731",
+      "target": "http://snomed.info/sct",
+      "targetVersion": "http://snomed.info/sct/32506021000036107/version/20260731",
+      "element": [
+        {
+          "code": "399981008",
+          "target": [
+            {
+              "code": "404684003",
+              "equivalence": "subsumes"
+            },
+            {
+              "code": "404684003",
+              "equivalence": "subsumes"
+            }
+          ]
+        },
+        {
+          "code": "363346000",
+          "target": [
+            {
+              "code": "363346000",
+              "equivalence": "subsumes"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "source": "http://snomed.info/sct",
+      "sourceVersion": "http://snomed.info/sct/32506021000036107/version/20260731",
+      "target": "http://snomed.info/sct",
+      "targetVersion": "http://snomed.info/sct/32506021000036107/version/20260731",
+      "element": [
+        {
+          "code": "399981008",
+          "target": [
+            {
+              "code": "404684003",
+              "equivalence": "subsumes"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

r/tests/testthat/test-encoder.R

@@ -70,6 +70,29 @@ test_that("construction produces the documented identity plus subsumption matrix
   expect_equal(as.matrix(encoder$encoded), expected_encoding())
 })
 
+test_that("a repeated closure pair still sets its cell to 1, not a count", {
+  # Arrange - a closure response that reports the same (399981008, 404684003)
+  # pair three times, twice within one group and once in a second group, and
+  # reports 363346000 as subsuming itself, which collides with the identity
+  # cell. Servers are free to return either; the encoding must stay multi-hot.
+  encoder <- suppressMessages(with_fixture_api(
+    fhir_tx_encoder(scope = test_scope, tx_url = test_tx_url),
+    expand = "expand-single-page",
+    closure_update = "closure-update-duplicates"
+  ))
+
+  # Assert - the repeated pair and the self-pair are both exactly 1. Building
+  # the matrix from triplets without deduplicating them would sum the
+  # duplicates, giving 3 and 2 respectively.
+  cell <- function(source, target) {
+    encoder$encoded[encoder$index[[source]], encoder$index[[target]]]
+  }
+  expect_equal(cell("399981008", "404684003"), 1)
+  expect_equal(cell("363346000", "363346000"), 1)
+  # Nothing anywhere in the encoding may exceed 1.
+  expect_equal(max(encoder$encoded), 1)
+})
+
 test_that("construction records codes, displays, feature names, index and scope", {
   # Arrange / Act
   encoder <- build_test_encoder()

r/tests/testthat/test-properties.R

@@ -393,9 +393,22 @@ test_that("no properties at all yields a matrix with one row per concept and no
 })
 
 test_that("feature names are sorted in byte order rather than the user's locale", {
-  # Arrange - under the en_AU (and en_US) collation R sorts these as
-  # "_x=1", "a=1", "Z=1"; scikit-learn's DictVectorizer sorts by code point,
-  # giving "Z=1", "_x=1", "a=1". A locale-collated sort therefore fails here.
+  # Arrange - testthat runs tests under LC_COLLATE=C, where a locale-collated
+  # sort and a byte-order sort agree, so the test would pass either way. Switch
+  # to a collation that disagrees: under en_AU, R sorts these as "_x=1", "a=1",
+  # "Z=1", whereas scikit-learn's DictVectorizer sorts by code point, giving
+  # "Z=1", "_x=1", "a=1".
+  skip_if_not(
+    identical(
+      suppressWarnings(withr::with_locale(
+        c(LC_COLLATE = "en_AU.UTF-8"),
+        sort(c("Z", "_x", "a"))
+      )),
+      c("_x", "a", "Z")
+    ),
+    "en_AU.UTF-8 collation is unavailable"
+  )
+  withr::local_locale(c(LC_COLLATE = "en_AU.UTF-8"))
   lists <- list(list(Z = "1", "_x" = "1", a = "1"))
 
   # Act