code: def test_something(path=None, new_home=None):
      # will refuse to work on dataset without a dataset
      assert_raises(ValueError, ConfigManager, source="branch")
      # now read the example config
      cfg = ConfigManager(
          GitRepo(opj(path, "ds"), create=True), source="branch"
      )
      assert_equal(len(cfg), 5)
      assert_in("something.user", cfg)
      # multi-value
      assert_equal(len(cfg["something.user"]), 2)
      assert_equal(
          cfg["something.user"],
          ("name=Jane Doe", "email=jd@example.com"),
      )
  
      assert_true(cfg.has_section("something"))
      assert_false(cfg.has_section("somethingelse"))
      assert_equal(
          sorted(cfg.sections()),
          ["onemore.complicated の beast with.dot", "something"],
      )
      assert_true(cfg.has_option("something", "user"))
      assert_false(cfg.has_option("something", "us?er"))
      assert_false(cfg.has_option("some?thing", "user"))
      assert_equal(
          sorted(cfg.options("something")),
          ["empty", "myint", "novalue", "user"],
      )
      assert_equal(
          cfg.options("onemore.complicated の beast with.dot"),
          ["findme"],
      )
  
      assert_equal(
          sorted(cfg.items()),
          [
              ("onemore.complicated の beast with.dot.findme", "5.0"),
              ("something.empty", ""),
              ("something.myint", "3"),
              ("something.novalue", None),
              (
                  "something.user",
                  ("name=Jane Doe", "email=jd@example.com"),
              ),
          ],
      )
      assert_equal(
          sorted(cfg.items("something")),
          [
              ("something.empty", ""),
              ("something.myint", "3"),
              ("something.novalue", None),
              (
                  "something.user",
                  ("name=Jane Doe", "email=jd@example.com"),
              ),
          ],
      )
  
      # by default get last value only
      assert_equal(cfg.get("something.user"), "email=jd@example.com")
      # but can get all values
      assert_equal(
          cfg.get("something.user", get_all=True),
          ("name=Jane Doe", "email=jd@example.com"),
      )
      assert_raises(KeyError, cfg.__getitem__, "somedthing.user")
      assert_equal(
          cfg.getfloat(
              "onemore.complicated の beast with.dot", "findme"
          ),
          5.0,
      )
      assert_equal(cfg.getint("something", "myint"), 3)
      assert_equal(cfg.getbool("something", "myint"), True)
      # git demands a key without value at all to be used as a flag, thus True
      assert_equal(cfg.getbool("something", "novalue"), True)
      assert_equal(cfg.get("something.novalue"), None)
      # empty value is False
      assert_equal(cfg.getbool("something", "empty"), False)
      assert_equal(cfg.get("something.empty"), "")
      assert_equal(cfg.getbool("doesnot", "exist", default=True), True)
      assert_raises(TypeError, cfg.getbool, "something", "user")
  
      # gitpython-style access
      assert_equal(
          cfg.get("something.myint"),
          cfg.get_value("something", "myint"),
      )
      assert_equal(
          cfg.get_value("doesnot", "exist", default="oohaaa"), "oohaaa"
      )
      # weird, but that is how it is
      assert_raises(
          KeyError, cfg.get_value, "doesnot", "exist", default=None
      )
  
      # modification follows
      cfg.add("something.new", "の")
      assert_equal(cfg.get("something.new"), "の")
      # sections are added on demand
      cfg.add("unheard.of", "fame")
      assert_true(cfg.has_section("unheard.of"))
      comp = cfg.items("something")
      cfg.rename_section("something", "this")
      assert_true(cfg.has_section("this"))
      assert_false(cfg.has_section("something"))
      # direct comparison would fail, because of section prefix
      assert_equal(len(cfg.items("this")), len(comp))
      # fail if no such section
      with swallow_logs():
          assert_raises(
              CommandError, cfg.rename_section, "nothere", "irrelevant"
          )
      assert_true(cfg.has_option("this", "myint"))
      cfg.unset("this.myint")
      assert_false(cfg.has_option("this", "myint"))
  
      # batch a changes
      cfg.add("mike.wants.to", "know", reload=False)
      assert_false("mike.wants.to" in cfg)
      cfg.add("mike.wants.to", "eat")
      assert_true("mike.wants.to" in cfg)
      assert_equal(len(cfg["mike.wants.to"]), 2)
  
      # set a new one:
      cfg.set("mike.should.have", "known")
      assert_in("mike.should.have", cfg)
      assert_equal(cfg["mike.should.have"], "known")
      # set an existing one:
      cfg.set("mike.should.have", "known better")
      assert_equal(cfg["mike.should.have"], "known better")
      # set, while there are several matching ones already:
      cfg.add("mike.should.have", "a meal")
      assert_equal(len(cfg["mike.should.have"]), 2)
      # raises with force=False
      assert_raises(
          CommandError,
          cfg.set,
          "mike.should.have",
          "a beer",
          force=False,
      )
      assert_equal(len(cfg["mike.should.have"]), 2)
      # replaces all matching ones with force=True
      cfg.set("mike.should.have", "a beer", force=True)
      assert_equal(cfg["mike.should.have"], "a beer")
  
      # test deprecated 'where' interface and old 'dataset' (not 'branch') value
      # TODO: remove along with the removal of deprecated 'where'
      cfg.set("mike.should.have", "wasknown", where="dataset")
      assert_equal(cfg["mike.should.have"], "wasknown")
      assert_equal(
          cfg.get_from_source("dataset", "mike.should.have"), "wasknown"
      )
  
      # fails unknown location
      assert_raises(
          ValueError, cfg.add, "somesuch", "shit", scope="umpalumpa"
      )
  
      # very carefully test non-local config
      # so carefully that even in case of bad weather Yarik doesn't find some
      # lame datalad unittest sections in his precious ~/.gitconfig
  
      # Note: An easier way to test this, would be to just set GIT_CONFIG_GLOBAL
      # to point somewhere else. However, this is not supported by git before
      # 2.32. Hence, stick with changed HOME in this test, but be sure to unset a
      # possible GIT_CONFIG_GLOBAL in addition.
  
      patched_env = os.environ.copy()
      patched_env.pop("GIT_CONFIG_GLOBAL", None)
      patched_env.update(get_home_envvars(new_home))
      with patch.dict(
          "os.environ",
          dict(patched_env, DATALAD_SNEAKY_ADDITION="ignore"),
          clear=True,
      ):
          global_gitconfig = opj(new_home, ".gitconfig")
          assert not exists(global_gitconfig)
          globalcfg = ConfigManager()
          assert_not_in("datalad.unittest.youcan", globalcfg)
          assert_in("datalad.sneaky.addition", globalcfg)
          cfg.add("datalad.unittest.youcan", "removeme", scope="global")
          assert exists(global_gitconfig)
          # it did not go into the dataset's config!
          assert_not_in("datalad.unittest.youcan", cfg)
          # does not monitor additions!
          globalcfg.reload(force=True)
          assert_in("datalad.unittest.youcan", globalcfg)
          with swallow_logs():
              assert_raises(
                  CommandError,
                  globalcfg.unset,
                  "datalad.unittest.youcan",
                  scope="local",
              )
          assert globalcfg.has_section("datalad.unittest")
          globalcfg.unset("datalad.unittest.youcan", scope="global")
          # but after we unset the only value -- that section is no longer listed
          assert not globalcfg.has_section("datalad.unittest")
          assert_not_in("datalad.unittest.youcan", globalcfg)
          ok_file_has_content(global_gitconfig, "")
  
      cfg = ConfigManager(
          Dataset(opj(path, "ds")),
          source="branch",
          overrides={"datalad.godgiven": True},
      )
      assert_equal(cfg.get("datalad.godgiven"), True)
      # setter has no effect
      cfg.set("datalad.godgiven", "false")
      assert_equal(cfg.get("datalad.godgiven"), True)
  
imports: import logging
  import os
  from os.path import exists
  from os.path import join
  from unittest.mock import patch
  import pytest
  from datalad import cfg
  from datalad.api import create
  from datalad.cmd import CommandError
  from datalad.config import ConfigManager, _where_to_scope, parse_gitconfig_dump, rewrite_url, write_config_section
  from datalad.distribution.dataset import Dataset
  from datalad.support.annexrepo import AnnexRepo
  from datalad.support.gitrepo import GitRepo
  from datalad.tests.utils_pytest import DEFAULT_BRANCH, DEFAULT_REMOTE, assert_equal, assert_false, assert_in, assert_not_equal, assert_not_in, assert_raises, assert_true, chpwd, ok_file_has_content, with_tempfile, with_testsui, with_tree
  from datalad.utils import Path, get_home_envvars, swallow_logs
label_desc: Use image node_id 2 for calling a global function with example usage: test_something(path, new_home) without return types