How to use the testtools.matchers.HasLength function in testtools

def test_schema_include_roscore(self):
        schema = catkin.CatkinPlugin.schema()

        # Check include-roscore property
        include_roscore = schema["properties"]["include-roscore"]
        expected = ("type", "default")
        self.assertThat(include_roscore, HasLength(len(expected)))
        for prop in expected:
            self.assertThat(include_roscore, Contains(prop))
        self.assertThat(include_roscore["type"], Equals("boolean"))
        self.assertThat(include_roscore["default"], Equals(True))

def test_schema(self):
        schema = catkin.CatkinPlugin.schema()

        properties = schema["properties"]
        expected = (
            "catkin-packages",
            "source-space",
            "include-roscore",
            "catkin-cmake-args",
            "underlay",
            "rosinstall-files",
            "recursive-rosinstall",
            "catkin-ros-master-uri",
        )
        self.assertThat(properties, HasLength(len(expected)))
        for prop in expected:
            self.assertThat(properties, Contains(prop))

def test_get_build_properties(self):
        expected_build_properties = make.MakePlugin.get_build_properties() + (
            ["configflags", "install-via"]
        )
        resulting_build_properties = autotools.AutotoolsPlugin.get_build_properties()

        self.assertThat(
            resulting_build_properties, HasLength(len(expected_build_properties))
        )

        for property in expected_build_properties:
            self.assertIn(property, resulting_build_properties)

return 'baz'

        m = Manager()
        self.assertThat(m._periodic_tasks, matchers.HasLength(2))
        self.assertEqual(periodic_task.DEFAULT_INTERVAL,
                         m._periodic_spacing['foo'])
        self.assertEqual(4, m._periodic_spacing['bar'])
        self.assertThat(
            m._periodic_spacing, matchers.Not(matchers.Contains('baz')))

        @periodic_task.periodic_task
        def external():
            return 42

        m.add_periodic_task(external)
        self.assertThat(m._periodic_tasks, matchers.HasLength(3))
        self.assertEqual(periodic_task.DEFAULT_INTERVAL,
                         m._periodic_spacing['external'])

def test_get_build_properties(self):
        expected_build_properties = ["catkin-cmake-args"]
        actual_build_properties = catkin.CatkinPlugin.get_build_properties()

        self.assertThat(
            actual_build_properties, HasLength(len(expected_build_properties))
        )

        for property in expected_build_properties:
            self.assertIn(property, actual_build_properties)

def test_get_pull_properties(self):
        expected_pull_properties = [
            "nodejs-version",
            "nodejs-package-manager",
            "nodejs-yarn-version",
        ]
        resulting_pull_properties = nodejs.NodePlugin.get_pull_properties()

        self.assertThat(
            resulting_pull_properties, HasLength(len(expected_pull_properties))
        )

        for property in expected_pull_properties:
            self.assertIn(property, resulting_pull_properties)

def test_find_system_dependencies_local_only(self):
        self.assertThat(
            catkin._find_system_dependencies(
                {"foo", "bar"}, self.rosdep_mock, self.rospack_mock, self.catkin_mock
            ),
            HasLength(0),
        )

        self.rosdep_mock.get_dependencies.assert_has_calls(
            [mock.call("foo"), mock.call("bar")], any_order=True
        )
        self.rosdep_mock.resolve_dependency.assert_not_called()
        self.catkin_mock.find.assert_not_called()

def test_get_build_properties(self):
        expected_build_properties = ["maven-options", "maven-targets"]
        resulting_build_properties = maven.MavenPlugin.get_build_properties()

        self.assertThat(
            resulting_build_properties, HasLength(len(expected_build_properties))
        )

        for property in expected_build_properties:
            self.assertIn(property, resulting_build_properties)

def test_schema_colcon_packages_ignore(self):
        schema = colcon.ColconPlugin.schema()

        # check colcon-packages-ignore property
        colcon_packages_ignore = schema["properties"]["colcon-packages-ignore"]
        expected = ("type", "default", "minitems", "items", "uniqueItems")
        self.assertThat(colcon_packages_ignore, HasLength(len(expected)))
        for prop in expected:
            self.assertThat(colcon_packages_ignore, Contains(prop))
        self.assertThat(colcon_packages_ignore["type"], Equals("array"))
        self.assertThat(colcon_packages_ignore["default"], Equals([]))
        self.assertThat(colcon_packages_ignore["minitems"], Equals(1))
        self.assertTrue(colcon_packages_ignore["uniqueItems"])
        self.assertThat(colcon_packages_ignore["items"], Contains("type"))
        self.assertThat(colcon_packages_ignore["items"]["type"], Equals("string"))

underlay = schema["properties"]["underlay"]
        expected = ("type", "properties", "required")
        self.assertThat(underlay, HasLength(len(expected)))
        for prop in expected:
            self.assertThat(underlay, Contains(prop))
        self.assertThat(underlay["type"], Equals("object"))

        underlay_required = underlay["required"]
        expected = ("build-path", "run-path")
        self.assertThat(underlay_required, HasLength(len(expected)))
        for prop in expected:
            self.assertThat(underlay_required, Contains(prop))

        underlay_properties = underlay["properties"]
        expected = ("build-path", "run-path")
        self.assertThat(underlay_properties, HasLength(len(expected)))
        for prop in expected:
            self.assertThat(underlay_properties, Contains(prop))
        underlay_build_path = underlay_properties["build-path"]
        self.assertThat(underlay_build_path, Contains("type"))
        self.assertThat(underlay_build_path["type"], Equals("string"))
        underlay_run_path = underlay_properties["run-path"]
        self.assertThat(underlay_run_path, Contains("type"))
        self.assertThat(underlay_run_path["type"], Equals("string"))