@@ -1451,31 +1451,6 @@ def annotation_dict(self, element_name: ElementName, imports: bool = True) -> di
         e = self.get_element(element_name, imports=imports)
         return {k: v.value for k, v in e.annotations.items()}
 
-    @lru_cache(None)
-    def class_slots(
-        self, class_name: CLASS_NAME, imports: bool = True, direct: bool = False, attributes: bool = True
-    ) -> list[SlotDefinitionName]:
-        """Return all slots for a class.
-
-        :param class_name:
-        :param imports: include imports closure
-        :param direct: only returns slots directly associated with a class (default is False)
-        :param attributes: include attribute declarations as well as slots (default is True)
-        :return: all slot names applicable for a class
-        """
-        ancs = [class_name] if direct else self.class_ancestors(class_name, imports=imports)
-        slots = []
-        for an in ancs:
-            a = self.get_class(an, imports)
-            slots += a.slots
-            if attributes:
-                slots += a.attributes.keys()
-        slots_nr = []
-        for s in slots:
-            if s not in slots_nr:
-                slots_nr.append(s)
-        return slots_nr
-
     @lru_cache(None)
     def induced_slot(
         self,
@@ -1587,6 +1562,31 @@ def _metaslots_for_slot(self):
         fake_slot = SlotDefinition("__FAKE")
         return vars(fake_slot).keys()
 
+    @lru_cache(None)
+    def class_slots(
+        self, class_name: CLASS_NAME, imports: bool = True, direct: bool = False, attributes: bool = True
+    ) -> list[SlotDefinitionName]:
+        """Return all slots for a class.
+
+        :param class_name:
+        :param imports: include imports closure
+        :param direct: only returns slots directly associated with a class (default is False)
+        :param attributes: include attribute declarations as well as slots (default is True)
+        :return: all slot names applicable for a class
+        """
+        ancs = [class_name] if direct else self.class_ancestors(class_name, imports=imports)
+        slots = []
+        for an in ancs:
+            a = self.get_class(an, imports)
+            slots += a.slots
+            if attributes and a.attributes:
+                slots += a.attributes.keys()
+        slots_nr = []
+        for s in slots:
+            if s not in slots_nr:
+                slots_nr.append(s)
+        return slots_nr
+
     @lru_cache(None)
     def class_induced_slots(self, class_name: CLASS_NAME | None = None, imports: bool = True) -> list[SlotDefinition]:
         """Retrieve all slots that are asserted or inferred for a class, with their inferred semantics.
@@ -1651,7 +1651,7 @@ def get_identifier_slot(self, cn: CLASS_NAME, use_key: bool = False, imports: bo
         :param imports:
         :return: slot that acts as identifier, if present
         """
-        for sn in self.class_slots(cn, imports=imports):
+        for sn in sorted(self.class_slots(cn, imports=imports)):
             s = self.induced_slot(sn, cn, imports=imports)
             if s.identifier:
                 return s
@@ -1667,7 +1667,7 @@ def get_key_slot(self, cn: CLASS_NAME, imports: bool = True) -> SlotDefinition |
         :param imports:
         :return: slot that acts as key, if present
         """
-        for sn in self.class_slots(cn, imports=imports):
+        for sn in sorted(self.class_slots(cn, imports=imports)):
             s = self.induced_slot(sn, cn, imports=imports)
             if s.key:
                 return s
 
@@ -70,6 +70,10 @@
 RELATED_TO = "related to"
 AGE_IN_YEARS = "age in years"
 
+EMPTY = ""
+ID = "identifier"
+KEY = "key"
+
 ALL_ELEMENTS = [PREFIXES, *SCHEMA_ELEMENTS]
 EXPECTED = {
     PREFIXES: {"sc1p1", "sc2p1"},
@@ -1631,6 +1635,125 @@ def test_type_and_slot_with_same_name() -> None:
     assert view.get_uri("test", imports=True) == "ex:test"
 
 
+@pytest.fixture(scope="module")
+def identifier_key_schema() -> str:
+    """Return a schema that defines a set of slots with identifiers and keys, and a test class to populate."""
+    return """
+# yaml-language-server: $schema=https://linkml.io/linkml-model/linkml_model/jsonschema/meta.schema.json
+id: https://w3id.org/linkml/examples/identifiers
+title: Identifiers and Keys
+name: identifiers
+description: Schema for testing identifiers and keys
+slots:
+  slot_a:
+  slot_b:
+  id_slot_a:
+    identifier: true
+  id_slot_b:
+    identifier: true
+  id_slot_false:
+    identifier: false
+  key_slot_a:
+    key: true
+  key_slot_b:
+    key: true
+  key_slot_false:
+    key: false
+
+classes:
+  TestClass:
+    slots:
+      - slot_a
+      - slot_b
+"""
+
+
+@pytest.mark.parametrize("id_slot_a", [EMPTY, "id_slot_a"])
+@pytest.mark.parametrize("id_slot_b", [EMPTY, "id_slot_b"])
+@pytest.mark.parametrize("id_slot_false", [EMPTY, "id_slot_false"])
+@pytest.mark.parametrize("key_slot_a", [EMPTY, "key_slot_a"])
+@pytest.mark.parametrize("key_slot_b", [EMPTY, "key_slot_b"])
+@pytest.mark.parametrize("key_slot_false", [EMPTY, "key_slot_false"])
+def test_get_identifier_get_key_slot(
+    identifier_key_schema: str,
+    id_slot_a: str,
+    id_slot_b: str,
+    id_slot_false: str,
+    key_slot_a: str,
+    key_slot_b: str,
+    key_slot_false: str,
+) -> None:
+    """Test the retrieval of "identifier" and "key" slots in classes in the schema.
+
+    The parameters represent the slots to be added to the test class; if the value of the parameter is EMPTY,
+    the slot is not added. If the parameter is a string, that slot is added to the test class.
+
+    For example, given the following set of parameters:
+
+    id_slot_a: "id_slot_a"
+    id_slot_b: EMPTY
+    id_slot_false: "id_slot_false"
+    key_slot_a: EMPTY
+    key_slot_b: EMPTY
+    key_slot_false: "key_slot_false"
+
+    The following lines would be added to the bottom of the identifier_key_schema:
+
+          - id_slot_a
+          - id_slot_false
+          - key_slot_false
+
+    resulting in the following structure for `TestClass`:
+
+    classes:
+      TestClass:
+        slots:
+          - slot_a
+          - slot_b
+          - id_slot_a
+          - id_slot_false
+          - key_slot_false
+
+    This allows the testing of a large number of combinations without having to generate all 2^^6 (64) manually.
+    """
+    all_id_slots = [id_slot_a, id_slot_b, id_slot_false]
+    all_key_slots = [key_slot_a, key_slot_b, key_slot_false]
+
+    for k in [*all_id_slots, *all_key_slots]:
+        if k:
+            identifier_key_schema += f"      - {k}\n"
+
+    sv = SchemaView(identifier_key_schema)
+    test_class_slots = sv.class_slots("TestClass")
+    # ensure that the correct slots are in the schema
+    assert set(test_class_slots) == {"slot_a", "slot_b", *[s for s in [*all_id_slots, *all_key_slots] if s]}
+
+    # Generate the expected slots to be returned by `get_***_slot` for identifiers and keys.
+    # Note that id_slot_false and key_slot_false have `identifier` and `key` set to `false`,
+    # so we would not expect `get_identifier_slot` or `get_key_slot` to return these slots.
+    # If the value from the parameters is EMPTY, the attribute is not present.
+    expected = {
+        # expected result of get_identifier_slot
+        ID: id_slot_a or id_slot_b,
+        # expected result of get_identifier_slot, falling back on get_key_slot
+        f"{ID}_or_{KEY}": id_slot_a or id_slot_b or key_slot_a or key_slot_b,
+        # expected result of get_key_slot
+        KEY: key_slot_a or key_slot_b,
+    }
+
+    got = {
+        ID: sv.get_identifier_slot("TestClass", use_key=False),
+        f"{ID}_or_{KEY}": sv.get_identifier_slot("TestClass", use_key=True),
+        KEY: sv.get_key_slot("TestClass"),
+    }
+
+    for id_key, exp in expected.items():
+        if exp:
+            assert got[id_key].name == exp
+        else:
+            assert got[id_key] is None
+
+
 """
 merge_schema tests: https://github.com/linkml/linkml/issues/1143
 """