Add files using upload-large-folder tool

third_party/CityFlow/extern/pybind11/.git.bak/hooks/applypatch-msg.sample

@@ -1,15 +1,15 @@
-#!/bin/sh
-#
-# An example hook script to check the commit log message taken by
-# applypatch from an e-mail message.
-#
-# The hook should exit with non-zero status after issuing an
-# appropriate message if it wants to stop the commit.  The hook is
-# allowed to edit the commit message file.
-#
-# To enable this hook, rename this file to "applypatch-msg".
-
-. git-sh-setup
-commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
-test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
-:
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
+test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
+:

third_party/CityFlow/extern/pybind11/.git.bak/hooks/commit-msg.sample

@@ -1,24 +1,24 @@
-#!/bin/sh
-#
-# An example hook script to check the commit log message.
-# Called by "git commit" with one argument, the name of the file
-# that has the commit message.  The hook should exit with non-zero
-# status after issuing an appropriate message if it wants to stop the
-# commit.  The hook is allowed to edit the commit message file.
-#
-# To enable this hook, rename this file to "commit-msg".
-
-# Uncomment the below to add a Signed-off-by line to the message.
-# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
-# hook is more suited to it.
-#
-# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
-# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
-
-# This example catches duplicate Signed-off-by lines.
-
-test "" = "$(grep '^Signed-off-by: ' "$1" |
-	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
-	echo >&2 Duplicate Signed-off-by lines.
-	exit 1
-}
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

third_party/CityFlow/extern/pybind11/.git.bak/hooks/fsmonitor-watchman.sample

@@ -1,174 +1,174 @@
-#!/usr/bin/perl
-
-use strict;
-use warnings;
-use IPC::Open2;
-
-# An example hook script to integrate Watchman
-# (https://facebook.github.io/watchman/) with git to speed up detecting
-# new and modified files.
-#
-# The hook is passed a version (currently 2) and last update token
-# formatted as a string and outputs to stdout a new update token and
-# all files that have been modified since the update token. Paths must
-# be relative to the root of the working tree and separated by a single NUL.
-#
-# To enable this hook, rename this file to "query-watchman" and set
-# 'git config core.fsmonitor .git/hooks/query-watchman'
-#
-my ($version, $last_update_token) = @ARGV;
-
-# Uncomment for debugging
-# print STDERR "$0 $version $last_update_token\n";
-
-# Check the hook interface version
-if ($version ne 2) {
-	die "Unsupported query-fsmonitor hook version '$version'.\n" .
-	    "Falling back to scanning...\n";
-}
-
-my $git_work_tree = get_working_dir();
-
-my $retry = 1;
-
-my $json_pkg;
-eval {
-	require JSON::XS;
-	$json_pkg = "JSON::XS";
-	1;
-} or do {
-	require JSON::PP;
-	$json_pkg = "JSON::PP";
-};
-
-launch_watchman();
-
-sub launch_watchman {
-	my $o = watchman_query();
-	if (is_work_tree_watched($o)) {
-		output_result($o->{clock}, @{$o->{files}});
-	}
-}
-
-sub output_result {
-	my ($clockid, @files) = @_;
-
-	# Uncomment for debugging watchman output
-	# open (my $fh, ">", ".git/watchman-output.out");
-	# binmode $fh, ":utf8";
-	# print $fh "$clockid\n@files\n";
-	# close $fh;
-
-	binmode STDOUT, ":utf8";
-	print $clockid;
-	print "\0";
-	local $, = "\0";
-	print @files;
-}
-
-sub watchman_clock {
-	my $response = qx/watchman clock "$git_work_tree"/;
-	die "Failed to get clock id on '$git_work_tree'.\n" .
-		"Falling back to scanning...\n" if $? != 0;
-
-	return $json_pkg->new->utf8->decode($response);
-}
-
-sub watchman_query {
-	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
-	or die "open2() failed: $!\n" .
-	"Falling back to scanning...\n";
-
-	# In the query expression below we're asking for names of files that
-	# changed since $last_update_token but not from the .git folder.
-	#
-	# To accomplish this, we're using the "since" generator to use the
-	# recency index to select candidate nodes and "fields" to limit the
-	# output to file names only. Then we're using the "expression" term to
-	# further constrain the results.
-	my $last_update_line = "";
-	if (substr($last_update_token, 0, 1) eq "c") {
-		$last_update_token = "\"$last_update_token\"";
-		$last_update_line = qq[\n"since": $last_update_token,];
-	}
-	my $query = <<"	END";
-		["query", "$git_work_tree", {$last_update_line
-			"fields": ["name"],
-			"expression": ["not", ["dirname", ".git"]]
-		}]
-	END
-
-	# Uncomment for debugging the watchman query
-	# open (my $fh, ">", ".git/watchman-query.json");
-	# print $fh $query;
-	# close $fh;
-
-	print CHLD_IN $query;
-	close CHLD_IN;
-	my $response = do {local $/; <CHLD_OUT>};
-
-	# Uncomment for debugging the watch response
-	# open ($fh, ">", ".git/watchman-response.json");
-	# print $fh $response;
-	# close $fh;
-
-	die "Watchman: command returned no output.\n" .
-	"Falling back to scanning...\n" if $response eq "";
-	die "Watchman: command returned invalid output: $response\n" .
-	"Falling back to scanning...\n" unless $response =~ /^\{/;
-
-	return $json_pkg->new->utf8->decode($response);
-}
-
-sub is_work_tree_watched {
-	my ($output) = @_;
-	my $error = $output->{error};
-	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
-		$retry--;
-		my $response = qx/watchman watch "$git_work_tree"/;
-		die "Failed to make watchman watch '$git_work_tree'.\n" .
-		    "Falling back to scanning...\n" if $? != 0;
-		$output = $json_pkg->new->utf8->decode($response);
-		$error = $output->{error};
-		die "Watchman: $error.\n" .
-		"Falling back to scanning...\n" if $error;
-
-		# Uncomment for debugging watchman output
-		# open (my $fh, ">", ".git/watchman-output.out");
-		# close $fh;
-
-		# Watchman will always return all files on the first query so
-		# return the fast "everything is dirty" flag to git and do the
-		# Watchman query just to get it over with now so we won't pay
-		# the cost in git to look up each individual file.
-		my $o = watchman_clock();
-		$error = $output->{error};
-
-		die "Watchman: $error.\n" .
-		"Falling back to scanning...\n" if $error;
-
-		output_result($o->{clock}, ("/"));
-		$last_update_token = $o->{clock};
-
-		eval { launch_watchman() };
-		return 0;
-	}
-
-	die "Watchman: $error.\n" .
-	"Falling back to scanning...\n" if $error;
-
-	return 1;
-}
-
-sub get_working_dir {
-	my $working_dir;
-	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
-		$working_dir = Win32::GetCwd();
-		$working_dir =~ tr/\\/\//;
-	} else {
-		require Cwd;
-		$working_dir = Cwd::cwd();
-	}
-
-	return $working_dir;
-}
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	my $last_update_line = "";
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+		$last_update_line = qq[\n"since": $last_update_token,];
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {$last_update_line
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

third_party/CityFlow/extern/pybind11/.git.bak/hooks/post-update.sample

@@ -1,8 +1,8 @@
-#!/bin/sh
-#
-# An example hook script to prepare a packed repository for use over
-# dumb transports.
-#
-# To enable this hook, rename this file to "post-update".
-
-exec git update-server-info
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

third_party/CityFlow/extern/pybind11/.git.bak/hooks/pre-applypatch.sample

@@ -1,14 +1,14 @@
-#!/bin/sh
-#
-# An example hook script to verify what is about to be committed
-# by applypatch from an e-mail message.
-#
-# The hook should exit with non-zero status after issuing an
-# appropriate message if it wants to stop the commit.
-#
-# To enable this hook, rename this file to "pre-applypatch".
-
-. git-sh-setup
-precommit="$(git rev-parse --git-path hooks/pre-commit)"
-test -x "$precommit" && exec "$precommit" ${1+"$@"}
-:
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+precommit="$(git rev-parse --git-path hooks/pre-commit)"
+test -x "$precommit" && exec "$precommit" ${1+"$@"}
+:

third_party/CityFlow/extern/pybind11/.git.bak/hooks/pre-commit.sample

@@ -1,49 +1,49 @@
-#!/bin/sh
-#
-# An example hook script to verify what is about to be committed.
-# Called by "git commit" with no arguments.  The hook should
-# exit with non-zero status after issuing an appropriate message if
-# it wants to stop the commit.
-#
-# To enable this hook, rename this file to "pre-commit".
-
-if git rev-parse --verify HEAD >/dev/null 2>&1
-then
-	against=HEAD
-else
-	# Initial commit: diff against an empty tree object
-	against=$(git hash-object -t tree /dev/null)
-fi
-
-# If you want to allow non-ASCII filenames set this variable to true.
-allownonascii=$(git config --type=bool hooks.allownonascii)
-
-# Redirect output to stderr.
-exec 1>&2
-
-# Cross platform projects tend to avoid non-ASCII filenames; prevent
-# them from being added to the repository. We exploit the fact that the
-# printable range starts at the space character and ends with tilde.
-if [ "$allownonascii" != "true" ] &&
-	# Note that the use of brackets around a tr range is ok here, (it's
-	# even required, for portability to Solaris 10's /usr/bin/tr), since
-	# the square bracket bytes happen to fall in the designated range.
-	test $(git diff-index --cached --name-only --diff-filter=A -z $against |
-	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
-then
-	cat <<\EOF
-Error: Attempt to add a non-ASCII file name.
-
-This can cause problems if you want to work with people on other platforms.
-
-To be portable it is advisable to rename the file.
-
-If you know what you are doing you can disable this check using:
-
-  git config hooks.allownonascii true
-EOF
-	exit 1
-fi
-
-# If there are whitespace errors, print the offending file names and fail.
-exec git diff-index --check --cached $against --
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff-index --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

third_party/CityFlow/extern/pybind11/.git.bak/hooks/pre-merge-commit.sample

@@ -1,13 +1,13 @@
-#!/bin/sh
-#
-# An example hook script to verify what is about to be committed.
-# Called by "git merge" with no arguments.  The hook should
-# exit with non-zero status after issuing an appropriate message to
-# stderr if it wants to stop the merge commit.
-#
-# To enable this hook, rename this file to "pre-merge-commit".
-
-. git-sh-setup
-test -x "$GIT_DIR/hooks/pre-commit" &&
-        exec "$GIT_DIR/hooks/pre-commit"
-:
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git merge" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message to
+# stderr if it wants to stop the merge commit.
+#
+# To enable this hook, rename this file to "pre-merge-commit".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+        exec "$GIT_DIR/hooks/pre-commit"
+:

third_party/CityFlow/extern/pybind11/.git.bak/hooks/pre-push.sample

@@ -1,53 +1,53 @@
-#!/bin/sh
-
-# An example hook script to verify what is about to be pushed.  Called by "git
-# push" after it has checked the remote status, but before anything has been
-# pushed.  If this script exits with a non-zero status nothing will be pushed.
-#
-# This hook is called with the following parameters:
-#
-# $1 -- Name of the remote to which the push is being done
-# $2 -- URL to which the push is being done
-#
-# If pushing without using a named remote those arguments will be equal.
-#
-# Information about the commits which are being pushed is supplied as lines to
-# the standard input in the form:
-#
-#   <local ref> <local oid> <remote ref> <remote oid>
-#
-# This sample shows how to prevent push of commits where the log message starts
-# with "WIP" (work in progress).
-
-remote="$1"
-url="$2"
-
-zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
-
-while read local_ref local_oid remote_ref remote_oid
-do
-	if test "$local_oid" = "$zero"
-	then
-		# Handle delete
-		:
-	else
-		if test "$remote_oid" = "$zero"
-		then
-			# New branch, examine all commits
-			range="$local_oid"
-		else
-			# Update to existing branch, examine new commits
-			range="$remote_oid..$local_oid"
-		fi
-
-		# Check for WIP commit
-		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
-		if test -n "$commit"
-		then
-			echo >&2 "Found WIP commit in $local_ref, not pushing"
-			exit 1
-		fi
-	fi
-done
-
-exit 0
+#!/bin/sh
+
+# An example hook script to verify what is about to be pushed.  Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed.  If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

third_party/CityFlow/extern/pybind11/.git.bak/hooks/pre-rebase.sample

@@ -1,169 +1,169 @@
-#!/bin/sh
-#
-# Copyright (c) 2006, 2008 Junio C Hamano
-#
-# The "pre-rebase" hook is run just before "git rebase" starts doing
-# its job, and can prevent the command from running by exiting with
-# non-zero status.
-#
-# The hook is called with the following parameters:
-#
-# $1 -- the upstream the series was forked from.
-# $2 -- the branch being rebased (or empty when rebasing the current branch).
-#
-# This sample shows how to prevent topic branches that are already
-# merged to 'next' branch from getting rebased, because allowing it
-# would result in rebasing already published history.
-
-publish=next
-basebranch="$1"
-if test "$#" = 2
-then
-	topic="refs/heads/$2"
-else
-	topic=`git symbolic-ref HEAD` ||
-	exit 0 ;# we do not interrupt rebasing detached HEAD
-fi
-
-case "$topic" in
-refs/heads/??/*)
-	;;
-*)
-	exit 0 ;# we do not interrupt others.
-	;;
-esac
-
-# Now we are dealing with a topic branch being rebased
-# on top of master.  Is it OK to rebase it?
-
-# Does the topic really exist?
-git show-ref -q "$topic" || {
-	echo >&2 "No such branch $topic"
-	exit 1
-}
-
-# Is topic fully merged to master?
-not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
-if test -z "$not_in_master"
-then
-	echo >&2 "$topic is fully merged to master; better remove it."
-	exit 1 ;# we could allow it, but there is no point.
-fi
-
-# Is topic ever merged to next?  If so you should not be rebasing it.
-only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
-only_next_2=`git rev-list ^master           ${publish} | sort`
-if test "$only_next_1" = "$only_next_2"
-then
-	not_in_topic=`git rev-list "^$topic" master`
-	if test -z "$not_in_topic"
-	then
-		echo >&2 "$topic is already up to date with master"
-		exit 1 ;# we could allow it, but there is no point.
-	else
-		exit 0
-	fi
-else
-	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
-	/usr/bin/perl -e '
-		my $topic = $ARGV[0];
-		my $msg = "* $topic has commits already merged to public branch:\n";
-		my (%not_in_next) = map {
-			/^([0-9a-f]+) /;
-			($1 => 1);
-		} split(/\n/, $ARGV[1]);
-		for my $elem (map {
-				/^([0-9a-f]+) (.*)$/;
-				[$1 => $2];
-			} split(/\n/, $ARGV[2])) {
-			if (!exists $not_in_next{$elem->[0]}) {
-				if ($msg) {
-					print STDERR $msg;
-					undef $msg;
-				}
-				print STDERR " $elem->[1]\n";
-			}
-		}
-	' "$topic" "$not_in_next" "$not_in_master"
-	exit 1
-fi
-
-<<\DOC_END
-
-This sample hook safeguards topic branches that have been
-published from being rewound.
-
-The workflow assumed here is:
-
- * Once a topic branch forks from "master", "master" is never
-   merged into it again (either directly or indirectly).
-
- * Once a topic branch is fully cooked and merged into "master",
-   it is deleted.  If you need to build on top of it to correct
-   earlier mistakes, a new topic branch is created by forking at
-   the tip of the "master".  This is not strictly necessary, but
-   it makes it easier to keep your history simple.
-
- * Whenever you need to test or publish your changes to topic
-   branches, merge them into "next" branch.
-
-The script, being an example, hardcodes the publish branch name
-to be "next", but it is trivial to make it configurable via
-$GIT_DIR/config mechanism.
-
-With this workflow, you would want to know:
-
-(1) ... if a topic branch has ever been merged to "next".  Young
-    topic branches can have stupid mistakes you would rather
-    clean up before publishing, and things that have not been
-    merged into other branches can be easily rebased without
-    affecting other people.  But once it is published, you would
-    not want to rewind it.
-
-(2) ... if a topic branch has been fully merged to "master".
-    Then you can delete it.  More importantly, you should not
-    build on top of it -- other people may already want to
-    change things related to the topic as patches against your
-    "master", so if you need further changes, it is better to
-    fork the topic (perhaps with the same name) afresh from the
-    tip of "master".
-
-Let's look at this example:
-
-		   o---o---o---o---o---o---o---o---o---o "next"
-		  /       /           /           /
-		 /   a---a---b A     /           /
-		/   /               /           /
-	       /   /   c---c---c---c B         /
-	      /   /   /             \         /
-	     /   /   /   b---b C     \       /
-	    /   /   /   /             \     /
-    ---o---o---o---o---o---o---o---o---o---o---o "master"
-
-
-A, B and C are topic branches.
-
- * A has one fix since it was merged up to "next".
-
- * B has finished.  It has been fully merged up to "master" and "next",
-   and is ready to be deleted.
-
- * C has not merged to "next" at all.
-
-We would want to allow C to be rebased, refuse A, and encourage
-B to be deleted.
-
-To compute (1):
-
-	git rev-list ^master ^topic next
-	git rev-list ^master        next
-
-	if these match, topic has not merged in next at all.
-
-To compute (2):
-
-	git rev-list master..topic
-
-	if this is empty, it is fully merged to "master".
-
-DOC_END
+#!/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

third_party/CityFlow/extern/pybind11/.git.bak/hooks/pre-receive.sample

@@ -1,24 +1,24 @@
-#!/bin/sh
-#
-# An example hook script to make use of push options.
-# The example simply echoes all push options that start with 'echoback='
-# and rejects all pushes when the "reject" push option is used.
-#
-# To enable this hook, rename this file to "pre-receive".
-
-if test -n "$GIT_PUSH_OPTION_COUNT"
-then
-	i=0
-	while test "$i" -lt "$GIT_PUSH_OPTION_COUNT"
-	do
-		eval "value=\$GIT_PUSH_OPTION_$i"
-		case "$value" in
-		echoback=*)
-			echo "echo from the pre-receive-hook: ${value#*=}" >&2
-			;;
-		reject)
-			exit 1
-		esac
-		i=$((i + 1))
-	done
-fi
+#!/bin/sh
+#
+# An example hook script to make use of push options.
+# The example simply echoes all push options that start with 'echoback='
+# and rejects all pushes when the "reject" push option is used.
+#
+# To enable this hook, rename this file to "pre-receive".
+
+if test -n "$GIT_PUSH_OPTION_COUNT"
+then
+	i=0
+	while test "$i" -lt "$GIT_PUSH_OPTION_COUNT"
+	do
+		eval "value=\$GIT_PUSH_OPTION_$i"
+		case "$value" in
+		echoback=*)
+			echo "echo from the pre-receive-hook: ${value#*=}" >&2
+			;;
+		reject)
+			exit 1
+		esac
+		i=$((i + 1))
+	done
+fi

third_party/CityFlow/extern/pybind11/.git.bak/hooks/prepare-commit-msg.sample

@@ -1,42 +1,42 @@
-#!/bin/sh
-#
-# An example hook script to prepare the commit log message.
-# Called by "git commit" with the name of the file that has the
-# commit message, followed by the description of the commit
-# message's source.  The hook's purpose is to edit the commit
-# message file.  If the hook fails with a non-zero status,
-# the commit is aborted.
-#
-# To enable this hook, rename this file to "prepare-commit-msg".
-
-# This hook includes three examples. The first one removes the
-# "# Please enter the commit message..." help message.
-#
-# The second includes the output of "git diff --name-status -r"
-# into the message, just before the "git status" output.  It is
-# commented because it doesn't cope with --amend or with squashed
-# commits.
-#
-# The third example adds a Signed-off-by line to the message, that can
-# still be edited.  This is rarely a good idea.
-
-COMMIT_MSG_FILE=$1
-COMMIT_SOURCE=$2
-SHA1=$3
-
-/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
-
-# case "$COMMIT_SOURCE,$SHA1" in
-#  ,|template,)
-#    /usr/bin/perl -i.bak -pe '
-#       print "\n" . `git diff --cached --name-status -r`
-# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
-#  *) ;;
-# esac
-
-# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
-# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
-# if test -z "$COMMIT_SOURCE"
-# then
-#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
-# fi
+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

third_party/CityFlow/extern/pybind11/.git.bak/hooks/push-to-checkout.sample

@@ -1,78 +1,78 @@
-#!/bin/sh
-
-# An example hook script to update a checked-out tree on a git push.
-#
-# This hook is invoked by git-receive-pack(1) when it reacts to git
-# push and updates reference(s) in its repository, and when the push
-# tries to update the branch that is currently checked out and the
-# receive.denyCurrentBranch configuration variable is set to
-# updateInstead.
-#
-# By default, such a push is refused if the working tree and the index
-# of the remote repository has any difference from the currently
-# checked out commit; when both the working tree and the index match
-# the current commit, they are updated to match the newly pushed tip
-# of the branch. This hook is to be used to override the default
-# behaviour; however the code below reimplements the default behaviour
-# as a starting point for convenient modification.
-#
-# The hook receives the commit with which the tip of the current
-# branch is going to be updated:
-commit=$1
-
-# It can exit with a non-zero status to refuse the push (when it does
-# so, it must not modify the index or the working tree).
-die () {
-	echo >&2 "$*"
-	exit 1
-}
-
-# Or it can make any necessary changes to the working tree and to the
-# index to bring them to the desired state when the tip of the current
-# branch is updated to the new commit, and exit with a zero status.
-#
-# For example, the hook can simply run git read-tree -u -m HEAD "$1"
-# in order to emulate git fetch that is run in the reverse direction
-# with git push, as the two-tree form of git read-tree -u -m is
-# essentially the same as git switch or git checkout that switches
-# branches while keeping the local changes in the working tree that do
-# not interfere with the difference between the branches.
-
-# The below is a more-or-less exact translation to shell of the C code
-# for the default behaviour for git's push-to-checkout hook defined in
-# the push_to_deploy() function in builtin/receive-pack.c.
-#
-# Note that the hook will be executed from the repository directory,
-# not from the working tree, so if you want to perform operations on
-# the working tree, you will have to adapt your code accordingly, e.g.
-# by adding "cd .." or using relative paths.
-
-if ! git update-index -q --ignore-submodules --refresh
-then
-	die "Up-to-date check failed"
-fi
-
-if ! git diff-files --quiet --ignore-submodules --
-then
-	die "Working directory has unstaged changes"
-fi
-
-# This is a rough translation of:
-#
-#   head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
-if git cat-file -e HEAD 2>/dev/null
-then
-	head=HEAD
-else
-	head=$(git hash-object -t tree --stdin </dev/null)
-fi
-
-if ! git diff-index --quiet --cached --ignore-submodules $head --
-then
-	die "Working directory has staged changes"
-fi
-
-if ! git read-tree -u -m "$commit"
-then
-	die "Could not update working tree to new HEAD"
-fi
+#!/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+#   head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

third_party/CityFlow/extern/pybind11/tests/test_async.py

@@ -1,24 +1,24 @@
-import pytest
-
-asyncio = pytest.importorskip("asyncio")
-m = pytest.importorskip("pybind11_tests.async_module")
-
-
-@pytest.fixture()
-def event_loop():
-    loop = asyncio.new_event_loop()
-    yield loop
-    loop.close()
-
-
-async def get_await_result(x):
-    return await x
-
-
-def test_await(event_loop):
-    assert event_loop.run_until_complete(get_await_result(m.SupportsAsync())) == 5
-
-
-def test_await_missing(event_loop):
-    with pytest.raises(TypeError):
-        event_loop.run_until_complete(get_await_result(m.DoesNotSupportAsync()))
+import pytest
+
+asyncio = pytest.importorskip("asyncio")
+m = pytest.importorskip("pybind11_tests.async_module")
+
+
+@pytest.fixture()
+def event_loop():
+    loop = asyncio.new_event_loop()
+    yield loop
+    loop.close()
+
+
+async def get_await_result(x):
+    return await x
+
+
+def test_await(event_loop):
+    assert event_loop.run_until_complete(get_await_result(m.SupportsAsync())) == 5
+
+
+def test_await_missing(event_loop):
+    with pytest.raises(TypeError):
+        event_loop.run_until_complete(get_await_result(m.DoesNotSupportAsync()))

third_party/CityFlow/extern/pybind11/tests/test_buffers.cpp

@@ -1,259 +1,259 @@
-/*
-    tests/test_buffers.cpp -- supporting Pythons' buffer protocol
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/complex.h>
-#include <pybind11/stl.h>
-
-#include "constructor_stats.h"
-#include "pybind11_tests.h"
-
-TEST_SUBMODULE(buffers, m) {
-    m.attr("long_double_and_double_have_same_size") = (sizeof(long double) == sizeof(double));
-
-    m.def("format_descriptor_format_buffer_info_equiv",
-          [](const std::string &cpp_name, const py::buffer &buffer) {
-              // https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables
-              static auto *format_table = new std::map<std::string, std::string>;
-              static auto *equiv_table
-                  = new std::map<std::string, bool (py::buffer_info::*)() const>;
-              if (format_table->empty()) {
-#define PYBIND11_ASSIGN_HELPER(...)                                                               \
-    (*format_table)[#__VA_ARGS__] = py::format_descriptor<__VA_ARGS__>::format();                 \
-    (*equiv_table)[#__VA_ARGS__] = &py::buffer_info::item_type_is_equivalent_to<__VA_ARGS__>;
-                  PYBIND11_ASSIGN_HELPER(PyObject *)
-                  PYBIND11_ASSIGN_HELPER(bool)
-                  PYBIND11_ASSIGN_HELPER(std::int8_t)
-                  PYBIND11_ASSIGN_HELPER(std::uint8_t)
-                  PYBIND11_ASSIGN_HELPER(std::int16_t)
-                  PYBIND11_ASSIGN_HELPER(std::uint16_t)
-                  PYBIND11_ASSIGN_HELPER(std::int32_t)
-                  PYBIND11_ASSIGN_HELPER(std::uint32_t)
-                  PYBIND11_ASSIGN_HELPER(std::int64_t)
-                  PYBIND11_ASSIGN_HELPER(std::uint64_t)
-                  PYBIND11_ASSIGN_HELPER(float)
-                  PYBIND11_ASSIGN_HELPER(double)
-                  PYBIND11_ASSIGN_HELPER(long double)
-                  PYBIND11_ASSIGN_HELPER(std::complex<float>)
-                  PYBIND11_ASSIGN_HELPER(std::complex<double>)
-                  PYBIND11_ASSIGN_HELPER(std::complex<long double>)
-#undef PYBIND11_ASSIGN_HELPER
-              }
-              return std::pair<std::string, bool>(
-                  (*format_table)[cpp_name], (buffer.request().*((*equiv_table)[cpp_name]))());
-          });
-
-    // test_from_python / test_to_python:
-    class Matrix {
-    public:
-        Matrix(py::ssize_t rows, py::ssize_t cols) : m_rows(rows), m_cols(cols) {
-            print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-            m_data = new float[(size_t) (rows * cols)];
-            memset(m_data, 0, sizeof(float) * (size_t) (rows * cols));
-        }
-
-        Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) {
-            print_copy_created(this,
-                               std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-            m_data = new float[(size_t) (m_rows * m_cols)];
-            memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
-        }
-
-        Matrix(Matrix &&s) noexcept : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) {
-            print_move_created(this);
-            s.m_rows = 0;
-            s.m_cols = 0;
-            s.m_data = nullptr;
-        }
-
-        ~Matrix() {
-            print_destroyed(this,
-                            std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            delete[] m_data;
-        }
-
-        Matrix &operator=(const Matrix &s) {
-            if (this == &s) {
-                return *this;
-            }
-            print_copy_assigned(this,
-                                std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            delete[] m_data;
-            m_rows = s.m_rows;
-            m_cols = s.m_cols;
-            m_data = new float[(size_t) (m_rows * m_cols)];
-            memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
-            return *this;
-        }
-
-        Matrix &operator=(Matrix &&s) noexcept {
-            print_move_assigned(this,
-                                std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            if (&s != this) {
-                delete[] m_data;
-                m_rows = s.m_rows;
-                m_cols = s.m_cols;
-                m_data = s.m_data;
-                s.m_rows = 0;
-                s.m_cols = 0;
-                s.m_data = nullptr;
-            }
-            return *this;
-        }
-
-        float operator()(py::ssize_t i, py::ssize_t j) const {
-            return m_data[(size_t) (i * m_cols + j)];
-        }
-
-        float &operator()(py::ssize_t i, py::ssize_t j) {
-            return m_data[(size_t) (i * m_cols + j)];
-        }
-
-        float *data() { return m_data; }
-
-        py::ssize_t rows() const { return m_rows; }
-        py::ssize_t cols() const { return m_cols; }
-
-    private:
-        py::ssize_t m_rows;
-        py::ssize_t m_cols;
-        float *m_data;
-    };
-    py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
-        .def(py::init<py::ssize_t, py::ssize_t>())
-        /// Construct from a buffer
-        .def(py::init([](const py::buffer &b) {
-            py::buffer_info info = b.request();
-            if (info.format != py::format_descriptor<float>::format() || info.ndim != 2) {
-                throw std::runtime_error("Incompatible buffer format!");
-            }
-
-            auto *v = new Matrix(info.shape[0], info.shape[1]);
-            memcpy(v->data(), info.ptr, sizeof(float) * (size_t) (v->rows() * v->cols()));
-            return v;
-        }))
-
-        .def("rows", &Matrix::rows)
-        .def("cols", &Matrix::cols)
-
-        /// Bare bones interface
-        .def("__getitem__",
-             [](const Matrix &m, std::pair<py::ssize_t, py::ssize_t> i) {
-                 if (i.first >= m.rows() || i.second >= m.cols()) {
-                     throw py::index_error();
-                 }
-                 return m(i.first, i.second);
-             })
-        .def("__setitem__",
-             [](Matrix &m, std::pair<py::ssize_t, py::ssize_t> i, float v) {
-                 if (i.first >= m.rows() || i.second >= m.cols()) {
-                     throw py::index_error();
-                 }
-                 m(i.first, i.second) = v;
-             })
-        /// Provide buffer access
-        .def_buffer([](Matrix &m) -> py::buffer_info {
-            return py::buffer_info(
-                m.data(),                          /* Pointer to buffer */
-                {m.rows(), m.cols()},              /* Buffer dimensions */
-                {sizeof(float) * size_t(m.cols()), /* Strides (in bytes) for each index */
-                 sizeof(float)});
-        });
-
-    // test_inherited_protocol
-    class SquareMatrix : public Matrix {
-    public:
-        explicit SquareMatrix(py::ssize_t n) : Matrix(n, n) {}
-    };
-    // Derived classes inherit the buffer protocol and the buffer access function
-    py::class_<SquareMatrix, Matrix>(m, "SquareMatrix").def(py::init<py::ssize_t>());
-
-    // test_pointer_to_member_fn
-    // Tests that passing a pointer to member to the base class works in
-    // the derived class.
-    struct Buffer {
-        int32_t value = 0;
-
-        py::buffer_info get_buffer_info() {
-            return py::buffer_info(
-                &value, sizeof(value), py::format_descriptor<int32_t>::format(), 1);
-        }
-    };
-    py::class_<Buffer>(m, "Buffer", py::buffer_protocol())
-        .def(py::init<>())
-        .def_readwrite("value", &Buffer::value)
-        .def_buffer(&Buffer::get_buffer_info);
-
-    class ConstBuffer {
-        std::unique_ptr<int32_t> value;
-
-    public:
-        int32_t get_value() const { return *value; }
-        void set_value(int32_t v) { *value = v; }
-
-        py::buffer_info get_buffer_info() const {
-            return py::buffer_info(
-                value.get(), sizeof(*value), py::format_descriptor<int32_t>::format(), 1);
-        }
-
-        ConstBuffer() : value(new int32_t{0}) {}
-    };
-    py::class_<ConstBuffer>(m, "ConstBuffer", py::buffer_protocol())
-        .def(py::init<>())
-        .def_property("value", &ConstBuffer::get_value, &ConstBuffer::set_value)
-        .def_buffer(&ConstBuffer::get_buffer_info);
-
-    struct DerivedBuffer : public Buffer {};
-    py::class_<DerivedBuffer>(m, "DerivedBuffer", py::buffer_protocol())
-        .def(py::init<>())
-        .def_readwrite("value", (int32_t DerivedBuffer::*) &DerivedBuffer::value)
-        .def_buffer(&DerivedBuffer::get_buffer_info);
-
-    struct BufferReadOnly {
-        const uint8_t value = 0;
-        explicit BufferReadOnly(uint8_t value) : value(value) {}
-
-        py::buffer_info get_buffer_info() { return py::buffer_info(&value, 1); }
-    };
-    py::class_<BufferReadOnly>(m, "BufferReadOnly", py::buffer_protocol())
-        .def(py::init<uint8_t>())
-        .def_buffer(&BufferReadOnly::get_buffer_info);
-
-    struct BufferReadOnlySelect {
-        uint8_t value = 0;
-        bool readonly = false;
-
-        py::buffer_info get_buffer_info() { return py::buffer_info(&value, 1, readonly); }
-    };
-    py::class_<BufferReadOnlySelect>(m, "BufferReadOnlySelect", py::buffer_protocol())
-        .def(py::init<>())
-        .def_readwrite("value", &BufferReadOnlySelect::value)
-        .def_readwrite("readonly", &BufferReadOnlySelect::readonly)
-        .def_buffer(&BufferReadOnlySelect::get_buffer_info);
-
-    // Expose buffer_info for testing.
-    py::class_<py::buffer_info>(m, "buffer_info")
-        .def(py::init<>())
-        .def_readonly("itemsize", &py::buffer_info::itemsize)
-        .def_readonly("size", &py::buffer_info::size)
-        .def_readonly("format", &py::buffer_info::format)
-        .def_readonly("ndim", &py::buffer_info::ndim)
-        .def_readonly("shape", &py::buffer_info::shape)
-        .def_readonly("strides", &py::buffer_info::strides)
-        .def_readonly("readonly", &py::buffer_info::readonly)
-        .def("__repr__", [](py::handle self) {
-            return py::str("itemsize={0.itemsize!r}, size={0.size!r}, format={0.format!r}, "
-                           "ndim={0.ndim!r}, shape={0.shape!r}, strides={0.strides!r}, "
-                           "readonly={0.readonly!r}")
-                .format(self);
-        });
-
-    m.def("get_buffer_info", [](const py::buffer &buffer) { return buffer.request(); });
-}
+/*
+    tests/test_buffers.cpp -- supporting Pythons' buffer protocol
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/complex.h>
+#include <pybind11/stl.h>
+
+#include "constructor_stats.h"
+#include "pybind11_tests.h"
+
+TEST_SUBMODULE(buffers, m) {
+    m.attr("long_double_and_double_have_same_size") = (sizeof(long double) == sizeof(double));
+
+    m.def("format_descriptor_format_buffer_info_equiv",
+          [](const std::string &cpp_name, const py::buffer &buffer) {
+              // https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables
+              static auto *format_table = new std::map<std::string, std::string>;
+              static auto *equiv_table
+                  = new std::map<std::string, bool (py::buffer_info::*)() const>;
+              if (format_table->empty()) {
+#define PYBIND11_ASSIGN_HELPER(...)                                                               \
+    (*format_table)[#__VA_ARGS__] = py::format_descriptor<__VA_ARGS__>::format();                 \
+    (*equiv_table)[#__VA_ARGS__] = &py::buffer_info::item_type_is_equivalent_to<__VA_ARGS__>;
+                  PYBIND11_ASSIGN_HELPER(PyObject *)
+                  PYBIND11_ASSIGN_HELPER(bool)
+                  PYBIND11_ASSIGN_HELPER(std::int8_t)
+                  PYBIND11_ASSIGN_HELPER(std::uint8_t)
+                  PYBIND11_ASSIGN_HELPER(std::int16_t)
+                  PYBIND11_ASSIGN_HELPER(std::uint16_t)
+                  PYBIND11_ASSIGN_HELPER(std::int32_t)
+                  PYBIND11_ASSIGN_HELPER(std::uint32_t)
+                  PYBIND11_ASSIGN_HELPER(std::int64_t)
+                  PYBIND11_ASSIGN_HELPER(std::uint64_t)
+                  PYBIND11_ASSIGN_HELPER(float)
+                  PYBIND11_ASSIGN_HELPER(double)
+                  PYBIND11_ASSIGN_HELPER(long double)
+                  PYBIND11_ASSIGN_HELPER(std::complex<float>)
+                  PYBIND11_ASSIGN_HELPER(std::complex<double>)
+                  PYBIND11_ASSIGN_HELPER(std::complex<long double>)
+#undef PYBIND11_ASSIGN_HELPER
+              }
+              return std::pair<std::string, bool>(
+                  (*format_table)[cpp_name], (buffer.request().*((*equiv_table)[cpp_name]))());
+          });
+
+    // test_from_python / test_to_python:
+    class Matrix {
+    public:
+        Matrix(py::ssize_t rows, py::ssize_t cols) : m_rows(rows), m_cols(cols) {
+            print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
+            // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+            m_data = new float[(size_t) (rows * cols)];
+            memset(m_data, 0, sizeof(float) * (size_t) (rows * cols));
+        }
+
+        Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) {
+            print_copy_created(this,
+                               std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
+            // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+            m_data = new float[(size_t) (m_rows * m_cols)];
+            memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
+        }
+
+        Matrix(Matrix &&s) noexcept : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) {
+            print_move_created(this);
+            s.m_rows = 0;
+            s.m_cols = 0;
+            s.m_data = nullptr;
+        }
+
+        ~Matrix() {
+            print_destroyed(this,
+                            std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
+            delete[] m_data;
+        }
+
+        Matrix &operator=(const Matrix &s) {
+            if (this == &s) {
+                return *this;
+            }
+            print_copy_assigned(this,
+                                std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
+            delete[] m_data;
+            m_rows = s.m_rows;
+            m_cols = s.m_cols;
+            m_data = new float[(size_t) (m_rows * m_cols)];
+            memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
+            return *this;
+        }
+
+        Matrix &operator=(Matrix &&s) noexcept {
+            print_move_assigned(this,
+                                std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
+            if (&s != this) {
+                delete[] m_data;
+                m_rows = s.m_rows;
+                m_cols = s.m_cols;
+                m_data = s.m_data;
+                s.m_rows = 0;
+                s.m_cols = 0;
+                s.m_data = nullptr;
+            }
+            return *this;
+        }
+
+        float operator()(py::ssize_t i, py::ssize_t j) const {
+            return m_data[(size_t) (i * m_cols + j)];
+        }
+
+        float &operator()(py::ssize_t i, py::ssize_t j) {
+            return m_data[(size_t) (i * m_cols + j)];
+        }
+
+        float *data() { return m_data; }
+
+        py::ssize_t rows() const { return m_rows; }
+        py::ssize_t cols() const { return m_cols; }
+
+    private:
+        py::ssize_t m_rows;
+        py::ssize_t m_cols;
+        float *m_data;
+    };
+    py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
+        .def(py::init<py::ssize_t, py::ssize_t>())
+        /// Construct from a buffer
+        .def(py::init([](const py::buffer &b) {
+            py::buffer_info info = b.request();
+            if (info.format != py::format_descriptor<float>::format() || info.ndim != 2) {
+                throw std::runtime_error("Incompatible buffer format!");
+            }
+
+            auto *v = new Matrix(info.shape[0], info.shape[1]);
+            memcpy(v->data(), info.ptr, sizeof(float) * (size_t) (v->rows() * v->cols()));
+            return v;
+        }))
+
+        .def("rows", &Matrix::rows)
+        .def("cols", &Matrix::cols)
+
+        /// Bare bones interface
+        .def("__getitem__",
+             [](const Matrix &m, std::pair<py::ssize_t, py::ssize_t> i) {
+                 if (i.first >= m.rows() || i.second >= m.cols()) {
+                     throw py::index_error();
+                 }
+                 return m(i.first, i.second);
+             })
+        .def("__setitem__",
+             [](Matrix &m, std::pair<py::ssize_t, py::ssize_t> i, float v) {
+                 if (i.first >= m.rows() || i.second >= m.cols()) {
+                     throw py::index_error();
+                 }
+                 m(i.first, i.second) = v;
+             })
+        /// Provide buffer access
+        .def_buffer([](Matrix &m) -> py::buffer_info {
+            return py::buffer_info(
+                m.data(),                          /* Pointer to buffer */
+                {m.rows(), m.cols()},              /* Buffer dimensions */
+                {sizeof(float) * size_t(m.cols()), /* Strides (in bytes) for each index */
+                 sizeof(float)});
+        });
+
+    // test_inherited_protocol
+    class SquareMatrix : public Matrix {
+    public:
+        explicit SquareMatrix(py::ssize_t n) : Matrix(n, n) {}
+    };
+    // Derived classes inherit the buffer protocol and the buffer access function
+    py::class_<SquareMatrix, Matrix>(m, "SquareMatrix").def(py::init<py::ssize_t>());
+
+    // test_pointer_to_member_fn
+    // Tests that passing a pointer to member to the base class works in
+    // the derived class.
+    struct Buffer {
+        int32_t value = 0;
+
+        py::buffer_info get_buffer_info() {
+            return py::buffer_info(
+                &value, sizeof(value), py::format_descriptor<int32_t>::format(), 1);
+        }
+    };
+    py::class_<Buffer>(m, "Buffer", py::buffer_protocol())
+        .def(py::init<>())
+        .def_readwrite("value", &Buffer::value)
+        .def_buffer(&Buffer::get_buffer_info);
+
+    class ConstBuffer {
+        std::unique_ptr<int32_t> value;
+
+    public:
+        int32_t get_value() const { return *value; }
+        void set_value(int32_t v) { *value = v; }
+
+        py::buffer_info get_buffer_info() const {
+            return py::buffer_info(
+                value.get(), sizeof(*value), py::format_descriptor<int32_t>::format(), 1);
+        }
+
+        ConstBuffer() : value(new int32_t{0}) {}
+    };
+    py::class_<ConstBuffer>(m, "ConstBuffer", py::buffer_protocol())
+        .def(py::init<>())
+        .def_property("value", &ConstBuffer::get_value, &ConstBuffer::set_value)
+        .def_buffer(&ConstBuffer::get_buffer_info);
+
+    struct DerivedBuffer : public Buffer {};
+    py::class_<DerivedBuffer>(m, "DerivedBuffer", py::buffer_protocol())
+        .def(py::init<>())
+        .def_readwrite("value", (int32_t DerivedBuffer::*) &DerivedBuffer::value)
+        .def_buffer(&DerivedBuffer::get_buffer_info);
+
+    struct BufferReadOnly {
+        const uint8_t value = 0;
+        explicit BufferReadOnly(uint8_t value) : value(value) {}
+
+        py::buffer_info get_buffer_info() { return py::buffer_info(&value, 1); }
+    };
+    py::class_<BufferReadOnly>(m, "BufferReadOnly", py::buffer_protocol())
+        .def(py::init<uint8_t>())
+        .def_buffer(&BufferReadOnly::get_buffer_info);
+
+    struct BufferReadOnlySelect {
+        uint8_t value = 0;
+        bool readonly = false;
+
+        py::buffer_info get_buffer_info() { return py::buffer_info(&value, 1, readonly); }
+    };
+    py::class_<BufferReadOnlySelect>(m, "BufferReadOnlySelect", py::buffer_protocol())
+        .def(py::init<>())
+        .def_readwrite("value", &BufferReadOnlySelect::value)
+        .def_readwrite("readonly", &BufferReadOnlySelect::readonly)
+        .def_buffer(&BufferReadOnlySelect::get_buffer_info);
+
+    // Expose buffer_info for testing.
+    py::class_<py::buffer_info>(m, "buffer_info")
+        .def(py::init<>())
+        .def_readonly("itemsize", &py::buffer_info::itemsize)
+        .def_readonly("size", &py::buffer_info::size)
+        .def_readonly("format", &py::buffer_info::format)
+        .def_readonly("ndim", &py::buffer_info::ndim)
+        .def_readonly("shape", &py::buffer_info::shape)
+        .def_readonly("strides", &py::buffer_info::strides)
+        .def_readonly("readonly", &py::buffer_info::readonly)
+        .def("__repr__", [](py::handle self) {
+            return py::str("itemsize={0.itemsize!r}, size={0.size!r}, format={0.format!r}, "
+                           "ndim={0.ndim!r}, shape={0.shape!r}, strides={0.strides!r}, "
+                           "readonly={0.readonly!r}")
+                .format(self);
+        });
+
+    m.def("get_buffer_info", [](const py::buffer &buffer) { return buffer.request(); });
+}

third_party/CityFlow/extern/pybind11/tests/test_buffers.py

@@ -1,228 +1,228 @@
-import ctypes
-import io
-import struct
-
-import pytest
-
-import env
-from pybind11_tests import ConstructorStats
-from pybind11_tests import buffers as m
-
-np = pytest.importorskip("numpy")
-
-if m.long_double_and_double_have_same_size:
-    # Determined by the compiler used to build the pybind11 tests
-    # (e.g. MSVC gets here, but MinGW might not).
-    np_float128 = None
-    np_complex256 = None
-else:
-    # Determined by the compiler used to build numpy (e.g. MinGW).
-    np_float128 = getattr(np, *["float128"] * 2)
-    np_complex256 = getattr(np, *["complex256"] * 2)
-
-CPP_NAME_FORMAT_NP_DTYPE_TABLE = [
-    ("PyObject *", "O", object),
-    ("bool", "?", np.bool_),
-    ("std::int8_t", "b", np.int8),
-    ("std::uint8_t", "B", np.uint8),
-    ("std::int16_t", "h", np.int16),
-    ("std::uint16_t", "H", np.uint16),
-    ("std::int32_t", "i", np.int32),
-    ("std::uint32_t", "I", np.uint32),
-    ("std::int64_t", "q", np.int64),
-    ("std::uint64_t", "Q", np.uint64),
-    ("float", "f", np.float32),
-    ("double", "d", np.float64),
-    ("long double", "g", np_float128),
-    ("std::complex<float>", "Zf", np.complex64),
-    ("std::complex<double>", "Zd", np.complex128),
-    ("std::complex<long double>", "Zg", np_complex256),
-]
-CPP_NAME_FORMAT_TABLE = [
-    (cpp_name, format)
-    for cpp_name, format, np_dtype in CPP_NAME_FORMAT_NP_DTYPE_TABLE
-    if np_dtype is not None
-]
-CPP_NAME_NP_DTYPE_TABLE = [
-    (cpp_name, np_dtype) for cpp_name, _, np_dtype in CPP_NAME_FORMAT_NP_DTYPE_TABLE
-]
-
-
-@pytest.mark.parametrize(("cpp_name", "np_dtype"), CPP_NAME_NP_DTYPE_TABLE)
-def test_format_descriptor_format_buffer_info_equiv(cpp_name, np_dtype):
-    if np_dtype is None:
-        pytest.skip(
-            f"cpp_name=`{cpp_name}`: `long double` and `double` have same size."
-        )
-    if isinstance(np_dtype, str):
-        pytest.skip(f"np.{np_dtype} does not exist.")
-    np_array = np.array([], dtype=np_dtype)
-    for other_cpp_name, expected_format in CPP_NAME_FORMAT_TABLE:
-        format, np_array_is_matching = m.format_descriptor_format_buffer_info_equiv(
-            other_cpp_name, np_array
-        )
-        assert format == expected_format
-        if other_cpp_name == cpp_name:
-            assert np_array_is_matching
-        else:
-            assert not np_array_is_matching
-
-
-def test_from_python():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.Matrix(np.array([1, 2, 3]))  # trying to assign a 1D array
-    assert str(excinfo.value) == "Incompatible buffer format!"
-
-    m3 = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
-    m4 = m.Matrix(m3)
-
-    for i in range(m4.rows()):
-        for j in range(m4.cols()):
-            assert m3[i, j] == m4[i, j]
-
-    cstats = ConstructorStats.get(m.Matrix)
-    assert cstats.alive() == 1
-    del m3, m4
-    assert cstats.alive() == 0
-    assert cstats.values() == ["2x3 matrix"]
-    assert cstats.copy_constructions == 0
-    # assert cstats.move_constructions >= 0  # Don't invoke any
-    assert cstats.copy_assignments == 0
-    assert cstats.move_assignments == 0
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2444
-# TODO: fix on recent PyPy
-@pytest.mark.xfail(
-    env.PYPY, reason="PyPy 7.3.7 doesn't clear this anymore", strict=False
-)
-def test_to_python():
-    mat = m.Matrix(5, 4)
-    assert memoryview(mat).shape == (5, 4)
-
-    assert mat[2, 3] == 0
-    mat[2, 3] = 4.0
-    mat[3, 2] = 7.0
-    assert mat[2, 3] == 4
-    assert mat[3, 2] == 7
-    assert struct.unpack_from("f", mat, (3 * 4 + 2) * 4) == (7,)
-    assert struct.unpack_from("f", mat, (2 * 4 + 3) * 4) == (4,)
-
-    mat2 = np.array(mat, copy=False)
-    assert mat2.shape == (5, 4)
-    assert abs(mat2).sum() == 11
-    assert mat2[2, 3] == 4
-    assert mat2[3, 2] == 7
-    mat2[2, 3] = 5
-    assert mat2[2, 3] == 5
-
-    cstats = ConstructorStats.get(m.Matrix)
-    assert cstats.alive() == 1
-    del mat
-    pytest.gc_collect()
-    assert cstats.alive() == 1
-    del mat2  # holds a mat reference
-    pytest.gc_collect()
-    assert cstats.alive() == 0
-    assert cstats.values() == ["5x4 matrix"]
-    assert cstats.copy_constructions == 0
-    # assert cstats.move_constructions >= 0  # Don't invoke any
-    assert cstats.copy_assignments == 0
-    assert cstats.move_assignments == 0
-
-
-def test_inherited_protocol():
-    """SquareMatrix is derived from Matrix and inherits the buffer protocol"""
-
-    matrix = m.SquareMatrix(5)
-    assert memoryview(matrix).shape == (5, 5)
-    assert np.asarray(matrix).shape == (5, 5)
-
-
-def test_pointer_to_member_fn():
-    for cls in [m.Buffer, m.ConstBuffer, m.DerivedBuffer]:
-        buf = cls()
-        buf.value = 0x12345678
-        value = struct.unpack("i", bytearray(buf))[0]
-        assert value == 0x12345678
-
-
-def test_readonly_buffer():
-    buf = m.BufferReadOnly(0x64)
-    view = memoryview(buf)
-    assert view[0] == 0x64
-    assert view.readonly
-    with pytest.raises(TypeError):
-        view[0] = 0
-
-
-def test_selective_readonly_buffer():
-    buf = m.BufferReadOnlySelect()
-
-    memoryview(buf)[0] = 0x64
-    assert buf.value == 0x64
-
-    io.BytesIO(b"A").readinto(buf)
-    assert buf.value == ord(b"A")
-
-    buf.readonly = True
-    with pytest.raises(TypeError):
-        memoryview(buf)[0] = 0
-    with pytest.raises(TypeError):
-        io.BytesIO(b"1").readinto(buf)
-
-
-def test_ctypes_array_1d():
-    char1d = (ctypes.c_char * 10)()
-    int1d = (ctypes.c_int * 15)()
-    long1d = (ctypes.c_long * 7)()
-
-    for carray in (char1d, int1d, long1d):
-        info = m.get_buffer_info(carray)
-        assert info.itemsize == ctypes.sizeof(carray._type_)
-        assert info.size == len(carray)
-        assert info.ndim == 1
-        assert info.shape == [info.size]
-        assert info.strides == [info.itemsize]
-        assert not info.readonly
-
-
-def test_ctypes_array_2d():
-    char2d = ((ctypes.c_char * 10) * 4)()
-    int2d = ((ctypes.c_int * 15) * 3)()
-    long2d = ((ctypes.c_long * 7) * 2)()
-
-    for carray in (char2d, int2d, long2d):
-        info = m.get_buffer_info(carray)
-        assert info.itemsize == ctypes.sizeof(carray[0]._type_)
-        assert info.size == len(carray) * len(carray[0])
-        assert info.ndim == 2
-        assert info.shape == [len(carray), len(carray[0])]
-        assert info.strides == [info.itemsize * len(carray[0]), info.itemsize]
-        assert not info.readonly
-
-
-def test_ctypes_from_buffer():
-    test_pystr = b"0123456789"
-    for pyarray in (test_pystr, bytearray(test_pystr)):
-        pyinfo = m.get_buffer_info(pyarray)
-
-        if pyinfo.readonly:
-            cbytes = (ctypes.c_char * len(pyarray)).from_buffer_copy(pyarray)
-            cinfo = m.get_buffer_info(cbytes)
-        else:
-            cbytes = (ctypes.c_char * len(pyarray)).from_buffer(pyarray)
-            cinfo = m.get_buffer_info(cbytes)
-
-        assert cinfo.size == pyinfo.size
-        assert cinfo.ndim == pyinfo.ndim
-        assert cinfo.shape == pyinfo.shape
-        assert cinfo.strides == pyinfo.strides
-        assert not cinfo.readonly
-
-
-def test_buffer_docstring():
-    assert (
-        m.get_buffer_info.__doc__.strip()
-        == "get_buffer_info(arg0: Buffer) -> pybind11_tests.buffers.buffer_info"
-    )
+import ctypes
+import io
+import struct
+
+import pytest
+
+import env
+from pybind11_tests import ConstructorStats
+from pybind11_tests import buffers as m
+
+np = pytest.importorskip("numpy")
+
+if m.long_double_and_double_have_same_size:
+    # Determined by the compiler used to build the pybind11 tests
+    # (e.g. MSVC gets here, but MinGW might not).
+    np_float128 = None
+    np_complex256 = None
+else:
+    # Determined by the compiler used to build numpy (e.g. MinGW).
+    np_float128 = getattr(np, *["float128"] * 2)
+    np_complex256 = getattr(np, *["complex256"] * 2)
+
+CPP_NAME_FORMAT_NP_DTYPE_TABLE = [
+    ("PyObject *", "O", object),
+    ("bool", "?", np.bool_),
+    ("std::int8_t", "b", np.int8),
+    ("std::uint8_t", "B", np.uint8),
+    ("std::int16_t", "h", np.int16),
+    ("std::uint16_t", "H", np.uint16),
+    ("std::int32_t", "i", np.int32),
+    ("std::uint32_t", "I", np.uint32),
+    ("std::int64_t", "q", np.int64),
+    ("std::uint64_t", "Q", np.uint64),
+    ("float", "f", np.float32),
+    ("double", "d", np.float64),
+    ("long double", "g", np_float128),
+    ("std::complex<float>", "Zf", np.complex64),
+    ("std::complex<double>", "Zd", np.complex128),
+    ("std::complex<long double>", "Zg", np_complex256),
+]
+CPP_NAME_FORMAT_TABLE = [
+    (cpp_name, format)
+    for cpp_name, format, np_dtype in CPP_NAME_FORMAT_NP_DTYPE_TABLE
+    if np_dtype is not None
+]
+CPP_NAME_NP_DTYPE_TABLE = [
+    (cpp_name, np_dtype) for cpp_name, _, np_dtype in CPP_NAME_FORMAT_NP_DTYPE_TABLE
+]
+
+
+@pytest.mark.parametrize(("cpp_name", "np_dtype"), CPP_NAME_NP_DTYPE_TABLE)
+def test_format_descriptor_format_buffer_info_equiv(cpp_name, np_dtype):
+    if np_dtype is None:
+        pytest.skip(
+            f"cpp_name=`{cpp_name}`: `long double` and `double` have same size."
+        )
+    if isinstance(np_dtype, str):
+        pytest.skip(f"np.{np_dtype} does not exist.")
+    np_array = np.array([], dtype=np_dtype)
+    for other_cpp_name, expected_format in CPP_NAME_FORMAT_TABLE:
+        format, np_array_is_matching = m.format_descriptor_format_buffer_info_equiv(
+            other_cpp_name, np_array
+        )
+        assert format == expected_format
+        if other_cpp_name == cpp_name:
+            assert np_array_is_matching
+        else:
+            assert not np_array_is_matching
+
+
+def test_from_python():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.Matrix(np.array([1, 2, 3]))  # trying to assign a 1D array
+    assert str(excinfo.value) == "Incompatible buffer format!"
+
+    m3 = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
+    m4 = m.Matrix(m3)
+
+    for i in range(m4.rows()):
+        for j in range(m4.cols()):
+            assert m3[i, j] == m4[i, j]
+
+    cstats = ConstructorStats.get(m.Matrix)
+    assert cstats.alive() == 1
+    del m3, m4
+    assert cstats.alive() == 0
+    assert cstats.values() == ["2x3 matrix"]
+    assert cstats.copy_constructions == 0
+    # assert cstats.move_constructions >= 0  # Don't invoke any
+    assert cstats.copy_assignments == 0
+    assert cstats.move_assignments == 0
+
+
+# https://foss.heptapod.net/pypy/pypy/-/issues/2444
+# TODO: fix on recent PyPy
+@pytest.mark.xfail(
+    env.PYPY, reason="PyPy 7.3.7 doesn't clear this anymore", strict=False
+)
+def test_to_python():
+    mat = m.Matrix(5, 4)
+    assert memoryview(mat).shape == (5, 4)
+
+    assert mat[2, 3] == 0
+    mat[2, 3] = 4.0
+    mat[3, 2] = 7.0
+    assert mat[2, 3] == 4
+    assert mat[3, 2] == 7
+    assert struct.unpack_from("f", mat, (3 * 4 + 2) * 4) == (7,)
+    assert struct.unpack_from("f", mat, (2 * 4 + 3) * 4) == (4,)
+
+    mat2 = np.array(mat, copy=False)
+    assert mat2.shape == (5, 4)
+    assert abs(mat2).sum() == 11
+    assert mat2[2, 3] == 4
+    assert mat2[3, 2] == 7
+    mat2[2, 3] = 5
+    assert mat2[2, 3] == 5
+
+    cstats = ConstructorStats.get(m.Matrix)
+    assert cstats.alive() == 1
+    del mat
+    pytest.gc_collect()
+    assert cstats.alive() == 1
+    del mat2  # holds a mat reference
+    pytest.gc_collect()
+    assert cstats.alive() == 0
+    assert cstats.values() == ["5x4 matrix"]
+    assert cstats.copy_constructions == 0
+    # assert cstats.move_constructions >= 0  # Don't invoke any
+    assert cstats.copy_assignments == 0
+    assert cstats.move_assignments == 0
+
+
+def test_inherited_protocol():
+    """SquareMatrix is derived from Matrix and inherits the buffer protocol"""
+
+    matrix = m.SquareMatrix(5)
+    assert memoryview(matrix).shape == (5, 5)
+    assert np.asarray(matrix).shape == (5, 5)
+
+
+def test_pointer_to_member_fn():
+    for cls in [m.Buffer, m.ConstBuffer, m.DerivedBuffer]:
+        buf = cls()
+        buf.value = 0x12345678
+        value = struct.unpack("i", bytearray(buf))[0]
+        assert value == 0x12345678
+
+
+def test_readonly_buffer():
+    buf = m.BufferReadOnly(0x64)
+    view = memoryview(buf)
+    assert view[0] == 0x64
+    assert view.readonly
+    with pytest.raises(TypeError):
+        view[0] = 0
+
+
+def test_selective_readonly_buffer():
+    buf = m.BufferReadOnlySelect()
+
+    memoryview(buf)[0] = 0x64
+    assert buf.value == 0x64
+
+    io.BytesIO(b"A").readinto(buf)
+    assert buf.value == ord(b"A")
+
+    buf.readonly = True
+    with pytest.raises(TypeError):
+        memoryview(buf)[0] = 0
+    with pytest.raises(TypeError):
+        io.BytesIO(b"1").readinto(buf)
+
+
+def test_ctypes_array_1d():
+    char1d = (ctypes.c_char * 10)()
+    int1d = (ctypes.c_int * 15)()
+    long1d = (ctypes.c_long * 7)()
+
+    for carray in (char1d, int1d, long1d):
+        info = m.get_buffer_info(carray)
+        assert info.itemsize == ctypes.sizeof(carray._type_)
+        assert info.size == len(carray)
+        assert info.ndim == 1
+        assert info.shape == [info.size]
+        assert info.strides == [info.itemsize]
+        assert not info.readonly
+
+
+def test_ctypes_array_2d():
+    char2d = ((ctypes.c_char * 10) * 4)()
+    int2d = ((ctypes.c_int * 15) * 3)()
+    long2d = ((ctypes.c_long * 7) * 2)()
+
+    for carray in (char2d, int2d, long2d):
+        info = m.get_buffer_info(carray)
+        assert info.itemsize == ctypes.sizeof(carray[0]._type_)
+        assert info.size == len(carray) * len(carray[0])
+        assert info.ndim == 2
+        assert info.shape == [len(carray), len(carray[0])]
+        assert info.strides == [info.itemsize * len(carray[0]), info.itemsize]
+        assert not info.readonly
+
+
+def test_ctypes_from_buffer():
+    test_pystr = b"0123456789"
+    for pyarray in (test_pystr, bytearray(test_pystr)):
+        pyinfo = m.get_buffer_info(pyarray)
+
+        if pyinfo.readonly:
+            cbytes = (ctypes.c_char * len(pyarray)).from_buffer_copy(pyarray)
+            cinfo = m.get_buffer_info(cbytes)
+        else:
+            cbytes = (ctypes.c_char * len(pyarray)).from_buffer(pyarray)
+            cinfo = m.get_buffer_info(cbytes)
+
+        assert cinfo.size == pyinfo.size
+        assert cinfo.ndim == pyinfo.ndim
+        assert cinfo.shape == pyinfo.shape
+        assert cinfo.strides == pyinfo.strides
+        assert not cinfo.readonly
+
+
+def test_buffer_docstring():
+    assert (
+        m.get_buffer_info.__doc__.strip()
+        == "get_buffer_info(arg0: Buffer) -> pybind11_tests.buffers.buffer_info"
+    )

third_party/CityFlow/extern/pybind11/tests/test_builtin_casters.cpp

@@ -1,392 +1,392 @@
-/*
-    tests/test_builtin_casters.cpp -- Casters available without any additional headers
-
-    Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/complex.h>
-
-#include "pybind11_tests.h"
-
-struct ConstRefCasted {
-    int tag;
-};
-
-PYBIND11_NAMESPACE_BEGIN(pybind11)
-PYBIND11_NAMESPACE_BEGIN(detail)
-template <>
-class type_caster<ConstRefCasted> {
-public:
-    static constexpr auto name = const_name<ConstRefCasted>();
-
-    // Input is unimportant, a new value will always be constructed based on the
-    // cast operator.
-    bool load(handle, bool) { return true; }
-
-    explicit operator ConstRefCasted &&() {
-        value = {1};
-        // NOLINTNEXTLINE(performance-move-const-arg)
-        return std::move(value);
-    }
-    explicit operator ConstRefCasted &() {
-        value = {2};
-        return value;
-    }
-    explicit operator ConstRefCasted *() {
-        value = {3};
-        return &value;
-    }
-
-    explicit operator const ConstRefCasted &() {
-        value = {4};
-        return value;
-    }
-    explicit operator const ConstRefCasted *() {
-        value = {5};
-        return &value;
-    }
-
-    // custom cast_op to explicitly propagate types to the conversion operators.
-    template <typename T_>
-    using cast_op_type =
-        /// const
-        conditional_t<
-            std::is_same<remove_reference_t<T_>, const ConstRefCasted *>::value,
-            const ConstRefCasted *,
-            conditional_t<
-                std::is_same<T_, const ConstRefCasted &>::value,
-                const ConstRefCasted &,
-                /// non-const
-                conditional_t<std::is_same<remove_reference_t<T_>, ConstRefCasted *>::value,
-                              ConstRefCasted *,
-                              conditional_t<std::is_same<T_, ConstRefCasted &>::value,
-                                            ConstRefCasted &,
-                                            /* else */ ConstRefCasted &&>>>>;
-
-private:
-    ConstRefCasted value = {0};
-};
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(pybind11)
-
-TEST_SUBMODULE(builtin_casters, m) {
-    PYBIND11_WARNING_PUSH
-    PYBIND11_WARNING_DISABLE_MSVC(4127)
-
-    // test_simple_string
-    m.def("string_roundtrip", [](const char *s) { return s; });
-
-    // test_unicode_conversion
-    // Some test characters in utf16 and utf32 encodings.  The last one (the 𝐀) contains a null
-    // byte
-    char32_t a32 = 0x61 /*a*/, z32 = 0x7a /*z*/, ib32 = 0x203d /*‽*/, cake32 = 0x1f382 /*🎂*/,
-             mathbfA32 = 0x1d400 /*𝐀*/;
-    char16_t b16 = 0x62 /*b*/, z16 = 0x7a, ib16 = 0x203d, cake16_1 = 0xd83c, cake16_2 = 0xdf82,
-             mathbfA16_1 = 0xd835, mathbfA16_2 = 0xdc00;
-    std::wstring wstr;
-    wstr.push_back(0x61);   // a
-    wstr.push_back(0x2e18); // ⸘
-    if (sizeof(wchar_t) == 2) {
-        wstr.push_back(mathbfA16_1);
-        wstr.push_back(mathbfA16_2);
-    } // 𝐀, utf16
-    else {
-        wstr.push_back((wchar_t) mathbfA32);
-    }                     // 𝐀, utf32
-    wstr.push_back(0x7a); // z
-
-    m.def("good_utf8_string", []() {
-        return std::string((const char *) u8"Say utf8\u203d \U0001f382 \U0001d400");
-    }); // Say utf8‽ 🎂 𝐀
-    m.def("good_utf16_string", [=]() {
-        return std::u16string({b16, ib16, cake16_1, cake16_2, mathbfA16_1, mathbfA16_2, z16});
-    }); // b‽🎂𝐀z
-    m.def("good_utf32_string", [=]() {
-        return std::u32string({a32, mathbfA32, cake32, ib32, z32});
-    });                                                 // a𝐀🎂‽z
-    m.def("good_wchar_string", [=]() { return wstr; }); // a‽𝐀z
-    m.def("bad_utf8_string", []() {
-        return std::string("abc\xd0"
-                           "def");
-    });
-    m.def("bad_utf16_string", [=]() { return std::u16string({b16, char16_t(0xd800), z16}); });
-    // Under Python 2.7, invalid unicode UTF-32 characters didn't appear to trigger
-    // UnicodeDecodeError
-    m.def("bad_utf32_string", [=]() { return std::u32string({a32, char32_t(0xd800), z32}); });
-    if (sizeof(wchar_t) == 2) {
-        m.def("bad_wchar_string", [=]() {
-            return std::wstring({wchar_t(0x61), wchar_t(0xd800)});
-        });
-    }
-    m.def("u8_Z", []() -> char { return 'Z'; });
-    m.def("u8_eacute", []() -> char { return '\xe9'; });
-    m.def("u16_ibang", [=]() -> char16_t { return ib16; });
-    m.def("u32_mathbfA", [=]() -> char32_t { return mathbfA32; });
-    m.def("wchar_heart", []() -> wchar_t { return 0x2665; });
-
-    // test_single_char_arguments
-    m.attr("wchar_size") = py::cast(sizeof(wchar_t));
-    m.def("ord_char", [](char c) -> int { return static_cast<unsigned char>(c); });
-    m.def("ord_char_lv", [](char &c) -> int { return static_cast<unsigned char>(c); });
-    m.def("ord_char16", [](char16_t c) -> uint16_t { return c; });
-    m.def("ord_char16_lv", [](char16_t &c) -> uint16_t { return c; });
-    m.def("ord_char32", [](char32_t c) -> uint32_t { return c; });
-    m.def("ord_wchar", [](wchar_t c) -> int { return c; });
-
-    // test_bytes_to_string
-    m.def("strlen", [](char *s) { return strlen(s); });
-    m.def("string_length", [](const std::string &s) { return s.length(); });
-
-#ifdef PYBIND11_HAS_U8STRING
-    m.attr("has_u8string") = true;
-    m.def("good_utf8_u8string", []() {
-        return std::u8string(u8"Say utf8\u203d \U0001f382 \U0001d400");
-    }); // Say utf8‽ 🎂 𝐀
-    m.def("bad_utf8_u8string", []() {
-        return std::u8string((const char8_t *) "abc\xd0"
-                                               "def");
-    });
-
-    m.def("u8_char8_Z", []() -> char8_t { return u8'Z'; });
-
-    // test_single_char_arguments
-    m.def("ord_char8", [](char8_t c) -> int { return static_cast<unsigned char>(c); });
-    m.def("ord_char8_lv", [](char8_t &c) -> int { return static_cast<unsigned char>(c); });
-#endif
-
-    // test_string_view
-#ifdef PYBIND11_HAS_STRING_VIEW
-    m.attr("has_string_view") = true;
-    m.def("string_view_print", [](std::string_view s) { py::print(s, s.size()); });
-    m.def("string_view16_print", [](std::u16string_view s) { py::print(s, s.size()); });
-    m.def("string_view32_print", [](std::u32string_view s) { py::print(s, s.size()); });
-    m.def("string_view_chars", [](std::string_view s) {
-        py::list l;
-        for (auto c : s) {
-            l.append((std::uint8_t) c);
-        }
-        return l;
-    });
-    m.def("string_view16_chars", [](std::u16string_view s) {
-        py::list l;
-        for (auto c : s) {
-            l.append((int) c);
-        }
-        return l;
-    });
-    m.def("string_view32_chars", [](std::u32string_view s) {
-        py::list l;
-        for (auto c : s) {
-            l.append((int) c);
-        }
-        return l;
-    });
-    m.def("string_view_return",
-          []() { return std::string_view((const char *) u8"utf8 secret \U0001f382"); });
-    m.def("string_view16_return",
-          []() { return std::u16string_view(u"utf16 secret \U0001f382"); });
-    m.def("string_view32_return",
-          []() { return std::u32string_view(U"utf32 secret \U0001f382"); });
-
-    // The inner lambdas here are to also test implicit conversion
-    using namespace std::literals;
-    m.def("string_view_bytes",
-          []() { return [](py::bytes b) { return b; }("abc \x80\x80 def"sv); });
-    m.def("string_view_str",
-          []() { return [](py::str s) { return s; }("abc \342\200\275 def"sv); });
-    m.def("string_view_from_bytes",
-          [](const py::bytes &b) { return [](std::string_view s) { return s; }(b); });
-    m.def("string_view_memoryview", []() {
-        static constexpr auto val = "Have some \360\237\216\202"sv;
-        return py::memoryview::from_memory(val);
-    });
-
-#    ifdef PYBIND11_HAS_U8STRING
-    m.def("string_view8_print", [](std::u8string_view s) { py::print(s, s.size()); });
-    m.def("string_view8_chars", [](std::u8string_view s) {
-        py::list l;
-        for (auto c : s)
-            l.append((std::uint8_t) c);
-        return l;
-    });
-    m.def("string_view8_return", []() { return std::u8string_view(u8"utf8 secret \U0001f382"); });
-    m.def("string_view8_str", []() { return py::str{std::u8string_view{u8"abc ‽ def"}}; });
-#    endif
-
-    struct TypeWithBothOperatorStringAndStringView {
-        // NOLINTNEXTLINE(google-explicit-constructor)
-        operator std::string() const { return "success"; }
-        // NOLINTNEXTLINE(google-explicit-constructor)
-        operator std::string_view() const { return "failure"; }
-    };
-    m.def("bytes_from_type_with_both_operator_string_and_string_view",
-          []() { return py::bytes(TypeWithBothOperatorStringAndStringView()); });
-    m.def("str_from_type_with_both_operator_string_and_string_view",
-          []() { return py::str(TypeWithBothOperatorStringAndStringView()); });
-#endif
-
-    // test_integer_casting
-    m.def("i32_str", [](std::int32_t v) { return std::to_string(v); });
-    m.def("u32_str", [](std::uint32_t v) { return std::to_string(v); });
-    m.def("i64_str", [](std::int64_t v) { return std::to_string(v); });
-    m.def("u64_str", [](std::uint64_t v) { return std::to_string(v); });
-
-    // test_int_convert
-    m.def("int_passthrough", [](int arg) { return arg; });
-    m.def(
-        "int_passthrough_noconvert", [](int arg) { return arg; }, py::arg{}.noconvert());
-
-    // test_tuple
-    m.def(
-        "pair_passthrough",
-        [](const std::pair<bool, std::string> &input) {
-            return std::make_pair(input.second, input.first);
-        },
-        "Return a pair in reversed order");
-    m.def(
-        "tuple_passthrough",
-        [](std::tuple<bool, std::string, int> input) {
-            return std::make_tuple(std::get<2>(input), std::get<1>(input), std::get<0>(input));
-        },
-        "Return a triple in reversed order");
-    m.def("empty_tuple", []() { return std::tuple<>(); });
-    static std::pair<RValueCaster, RValueCaster> lvpair;
-    static std::tuple<RValueCaster, RValueCaster, RValueCaster> lvtuple;
-    static std::pair<RValueCaster, std::tuple<RValueCaster, std::pair<RValueCaster, RValueCaster>>>
-        lvnested;
-    m.def("rvalue_pair", []() { return std::make_pair(RValueCaster{}, RValueCaster{}); });
-    m.def("lvalue_pair", []() -> const decltype(lvpair) & { return lvpair; });
-    m.def("rvalue_tuple",
-          []() { return std::make_tuple(RValueCaster{}, RValueCaster{}, RValueCaster{}); });
-    m.def("lvalue_tuple", []() -> const decltype(lvtuple) & { return lvtuple; });
-    m.def("rvalue_nested", []() {
-        return std::make_pair(
-            RValueCaster{},
-            std::make_tuple(RValueCaster{}, std::make_pair(RValueCaster{}, RValueCaster{})));
-    });
-    m.def("lvalue_nested", []() -> const decltype(lvnested) & { return lvnested; });
-
-    m.def(
-        "int_string_pair",
-        []() {
-            // Using no-destructor idiom to side-step warnings from overzealous compilers.
-            static auto *int_string_pair = new std::pair<int, std::string>{2, "items"};
-            return int_string_pair;
-        },
-        py::return_value_policy::reference);
-
-    // test_builtins_cast_return_none
-    m.def("return_none_string", []() -> std::string * { return nullptr; });
-    m.def("return_none_char", []() -> const char * { return nullptr; });
-    m.def("return_none_bool", []() -> bool * { return nullptr; });
-    m.def("return_none_int", []() -> int * { return nullptr; });
-    m.def("return_none_float", []() -> float * { return nullptr; });
-    m.def("return_none_pair", []() -> std::pair<int, int> * { return nullptr; });
-
-    // test_none_deferred
-    m.def("defer_none_cstring", [](char *) { return false; });
-    m.def("defer_none_cstring", [](const py::none &) { return true; });
-    m.def("defer_none_custom", [](UserType *) { return false; });
-    m.def("defer_none_custom", [](const py::none &) { return true; });
-    m.def("nodefer_none_void", [](void *) { return true; });
-    m.def("nodefer_none_void", [](const py::none &) { return false; });
-
-    // test_void_caster
-    m.def("load_nullptr_t", [](std::nullptr_t) {}); // not useful, but it should still compile
-    m.def("cast_nullptr_t", []() { return std::nullptr_t{}; });
-
-    // [workaround(intel)] ICC 20/21 breaks with py::arg().stuff, using py::arg{}.stuff works.
-
-    // test_bool_caster
-    m.def("bool_passthrough", [](bool arg) { return arg; });
-    m.def(
-        "bool_passthrough_noconvert", [](bool arg) { return arg; }, py::arg{}.noconvert());
-
-    // TODO: This should be disabled and fixed in future Intel compilers
-#if !defined(__INTEL_COMPILER)
-    // Test "bool_passthrough_noconvert" again, but using () instead of {} to construct py::arg
-    // When compiled with the Intel compiler, this results in segmentation faults when importing
-    // the module. Tested with icc (ICC) 2021.1 Beta 20200827, this should be tested again when
-    // a newer version of icc is available.
-    m.def(
-        "bool_passthrough_noconvert2", [](bool arg) { return arg; }, py::arg().noconvert());
-#endif
-
-    // test_reference_wrapper
-    m.def("refwrap_builtin", [](std::reference_wrapper<int> p) { return 10 * p.get(); });
-    m.def("refwrap_usertype", [](std::reference_wrapper<UserType> p) { return p.get().value(); });
-    m.def("refwrap_usertype_const",
-          [](std::reference_wrapper<const UserType> p) { return p.get().value(); });
-
-    m.def("refwrap_lvalue", []() -> std::reference_wrapper<UserType> {
-        static UserType x(1);
-        return std::ref(x);
-    });
-    m.def("refwrap_lvalue_const", []() -> std::reference_wrapper<const UserType> {
-        static UserType x(1);
-        return std::cref(x);
-    });
-
-    // Not currently supported (std::pair caster has return-by-value cast operator);
-    // triggers static_assert failure.
-    // m.def("refwrap_pair", [](std::reference_wrapper<std::pair<int, int>>) { });
-
-    m.def(
-        "refwrap_list",
-        [](bool copy) {
-            static IncType x1(1), x2(2);
-            py::list l;
-            for (const auto &f : {std::ref(x1), std::ref(x2)}) {
-                l.append(py::cast(
-                    f, copy ? py::return_value_policy::copy : py::return_value_policy::reference));
-            }
-            return l;
-        },
-        "copy"_a);
-
-    m.def("refwrap_iiw", [](const IncType &w) { return w.value(); });
-    m.def("refwrap_call_iiw", [](IncType &w, const py::function &f) {
-        py::list l;
-        l.append(f(std::ref(w)));
-        l.append(f(std::cref(w)));
-        IncType x(w.value());
-        l.append(f(std::ref(x)));
-        IncType y(w.value());
-        auto r3 = std::ref(y);
-        l.append(f(r3));
-        return l;
-    });
-
-    // test_complex
-    m.def("complex_cast", [](float x) { return "{}"_s.format(x); });
-    m.def("complex_cast",
-          [](std::complex<float> x) { return "({}, {})"_s.format(x.real(), x.imag()); });
-
-    // test int vs. long (Python 2)
-    m.def("int_cast", []() { return (int) 42; });
-    m.def("long_cast", []() { return (long) 42; });
-    m.def("longlong_cast", []() { return ULLONG_MAX; });
-
-    /// test void* cast operator
-    m.def("test_void_caster", []() -> bool {
-        void *v = (void *) 0xabcd;
-        py::object o = py::cast(v);
-        return py::cast<void *>(o) == v;
-    });
-
-    // Tests const/non-const propagation in cast_op.
-    m.def("takes", [](ConstRefCasted x) { return x.tag; });
-    m.def("takes_move", [](ConstRefCasted &&x) { return x.tag; });
-    m.def("takes_ptr", [](ConstRefCasted *x) { return x->tag; });
-    m.def("takes_ref", [](ConstRefCasted &x) { return x.tag; });
-    m.def("takes_ref_wrap", [](std::reference_wrapper<ConstRefCasted> x) { return x.get().tag; });
-    m.def("takes_const_ptr", [](const ConstRefCasted *x) { return x->tag; });
-    m.def("takes_const_ref", [](const ConstRefCasted &x) { return x.tag; });
-    m.def("takes_const_ref_wrap",
-          [](std::reference_wrapper<const ConstRefCasted> x) { return x.get().tag; });
-
-    PYBIND11_WARNING_POP
-}
+/*
+    tests/test_builtin_casters.cpp -- Casters available without any additional headers
+
+    Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/complex.h>
+
+#include "pybind11_tests.h"
+
+struct ConstRefCasted {
+    int tag;
+};
+
+PYBIND11_NAMESPACE_BEGIN(pybind11)
+PYBIND11_NAMESPACE_BEGIN(detail)
+template <>
+class type_caster<ConstRefCasted> {
+public:
+    static constexpr auto name = const_name<ConstRefCasted>();
+
+    // Input is unimportant, a new value will always be constructed based on the
+    // cast operator.
+    bool load(handle, bool) { return true; }
+
+    explicit operator ConstRefCasted &&() {
+        value = {1};
+        // NOLINTNEXTLINE(performance-move-const-arg)
+        return std::move(value);
+    }
+    explicit operator ConstRefCasted &() {
+        value = {2};
+        return value;
+    }
+    explicit operator ConstRefCasted *() {
+        value = {3};
+        return &value;
+    }
+
+    explicit operator const ConstRefCasted &() {
+        value = {4};
+        return value;
+    }
+    explicit operator const ConstRefCasted *() {
+        value = {5};
+        return &value;
+    }
+
+    // custom cast_op to explicitly propagate types to the conversion operators.
+    template <typename T_>
+    using cast_op_type =
+        /// const
+        conditional_t<
+            std::is_same<remove_reference_t<T_>, const ConstRefCasted *>::value,
+            const ConstRefCasted *,
+            conditional_t<
+                std::is_same<T_, const ConstRefCasted &>::value,
+                const ConstRefCasted &,
+                /// non-const
+                conditional_t<std::is_same<remove_reference_t<T_>, ConstRefCasted *>::value,
+                              ConstRefCasted *,
+                              conditional_t<std::is_same<T_, ConstRefCasted &>::value,
+                                            ConstRefCasted &,
+                                            /* else */ ConstRefCasted &&>>>>;
+
+private:
+    ConstRefCasted value = {0};
+};
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(pybind11)
+
+TEST_SUBMODULE(builtin_casters, m) {
+    PYBIND11_WARNING_PUSH
+    PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+    // test_simple_string
+    m.def("string_roundtrip", [](const char *s) { return s; });
+
+    // test_unicode_conversion
+    // Some test characters in utf16 and utf32 encodings.  The last one (the 𝐀) contains a null
+    // byte
+    char32_t a32 = 0x61 /*a*/, z32 = 0x7a /*z*/, ib32 = 0x203d /*‽*/, cake32 = 0x1f382 /*🎂*/,
+             mathbfA32 = 0x1d400 /*𝐀*/;
+    char16_t b16 = 0x62 /*b*/, z16 = 0x7a, ib16 = 0x203d, cake16_1 = 0xd83c, cake16_2 = 0xdf82,
+             mathbfA16_1 = 0xd835, mathbfA16_2 = 0xdc00;
+    std::wstring wstr;
+    wstr.push_back(0x61);   // a
+    wstr.push_back(0x2e18); // ⸘
+    if (sizeof(wchar_t) == 2) {
+        wstr.push_back(mathbfA16_1);
+        wstr.push_back(mathbfA16_2);
+    } // 𝐀, utf16
+    else {
+        wstr.push_back((wchar_t) mathbfA32);
+    }                     // 𝐀, utf32
+    wstr.push_back(0x7a); // z
+
+    m.def("good_utf8_string", []() {
+        return std::string((const char *) u8"Say utf8\u203d \U0001f382 \U0001d400");
+    }); // Say utf8‽ 🎂 𝐀
+    m.def("good_utf16_string", [=]() {
+        return std::u16string({b16, ib16, cake16_1, cake16_2, mathbfA16_1, mathbfA16_2, z16});
+    }); // b‽🎂𝐀z
+    m.def("good_utf32_string", [=]() {
+        return std::u32string({a32, mathbfA32, cake32, ib32, z32});
+    });                                                 // a𝐀🎂‽z
+    m.def("good_wchar_string", [=]() { return wstr; }); // a‽𝐀z
+    m.def("bad_utf8_string", []() {
+        return std::string("abc\xd0"
+                           "def");
+    });
+    m.def("bad_utf16_string", [=]() { return std::u16string({b16, char16_t(0xd800), z16}); });
+    // Under Python 2.7, invalid unicode UTF-32 characters didn't appear to trigger
+    // UnicodeDecodeError
+    m.def("bad_utf32_string", [=]() { return std::u32string({a32, char32_t(0xd800), z32}); });
+    if (sizeof(wchar_t) == 2) {
+        m.def("bad_wchar_string", [=]() {
+            return std::wstring({wchar_t(0x61), wchar_t(0xd800)});
+        });
+    }
+    m.def("u8_Z", []() -> char { return 'Z'; });
+    m.def("u8_eacute", []() -> char { return '\xe9'; });
+    m.def("u16_ibang", [=]() -> char16_t { return ib16; });
+    m.def("u32_mathbfA", [=]() -> char32_t { return mathbfA32; });
+    m.def("wchar_heart", []() -> wchar_t { return 0x2665; });
+
+    // test_single_char_arguments
+    m.attr("wchar_size") = py::cast(sizeof(wchar_t));
+    m.def("ord_char", [](char c) -> int { return static_cast<unsigned char>(c); });
+    m.def("ord_char_lv", [](char &c) -> int { return static_cast<unsigned char>(c); });
+    m.def("ord_char16", [](char16_t c) -> uint16_t { return c; });
+    m.def("ord_char16_lv", [](char16_t &c) -> uint16_t { return c; });
+    m.def("ord_char32", [](char32_t c) -> uint32_t { return c; });
+    m.def("ord_wchar", [](wchar_t c) -> int { return c; });
+
+    // test_bytes_to_string
+    m.def("strlen", [](char *s) { return strlen(s); });
+    m.def("string_length", [](const std::string &s) { return s.length(); });
+
+#ifdef PYBIND11_HAS_U8STRING
+    m.attr("has_u8string") = true;
+    m.def("good_utf8_u8string", []() {
+        return std::u8string(u8"Say utf8\u203d \U0001f382 \U0001d400");
+    }); // Say utf8‽ 🎂 𝐀
+    m.def("bad_utf8_u8string", []() {
+        return std::u8string((const char8_t *) "abc\xd0"
+                                               "def");
+    });
+
+    m.def("u8_char8_Z", []() -> char8_t { return u8'Z'; });
+
+    // test_single_char_arguments
+    m.def("ord_char8", [](char8_t c) -> int { return static_cast<unsigned char>(c); });
+    m.def("ord_char8_lv", [](char8_t &c) -> int { return static_cast<unsigned char>(c); });
+#endif
+
+    // test_string_view
+#ifdef PYBIND11_HAS_STRING_VIEW
+    m.attr("has_string_view") = true;
+    m.def("string_view_print", [](std::string_view s) { py::print(s, s.size()); });
+    m.def("string_view16_print", [](std::u16string_view s) { py::print(s, s.size()); });
+    m.def("string_view32_print", [](std::u32string_view s) { py::print(s, s.size()); });
+    m.def("string_view_chars", [](std::string_view s) {
+        py::list l;
+        for (auto c : s) {
+            l.append((std::uint8_t) c);
+        }
+        return l;
+    });
+    m.def("string_view16_chars", [](std::u16string_view s) {
+        py::list l;
+        for (auto c : s) {
+            l.append((int) c);
+        }
+        return l;
+    });
+    m.def("string_view32_chars", [](std::u32string_view s) {
+        py::list l;
+        for (auto c : s) {
+            l.append((int) c);
+        }
+        return l;
+    });
+    m.def("string_view_return",
+          []() { return std::string_view((const char *) u8"utf8 secret \U0001f382"); });
+    m.def("string_view16_return",
+          []() { return std::u16string_view(u"utf16 secret \U0001f382"); });
+    m.def("string_view32_return",
+          []() { return std::u32string_view(U"utf32 secret \U0001f382"); });
+
+    // The inner lambdas here are to also test implicit conversion
+    using namespace std::literals;
+    m.def("string_view_bytes",
+          []() { return [](py::bytes b) { return b; }("abc \x80\x80 def"sv); });
+    m.def("string_view_str",
+          []() { return [](py::str s) { return s; }("abc \342\200\275 def"sv); });
+    m.def("string_view_from_bytes",
+          [](const py::bytes &b) { return [](std::string_view s) { return s; }(b); });
+    m.def("string_view_memoryview", []() {
+        static constexpr auto val = "Have some \360\237\216\202"sv;
+        return py::memoryview::from_memory(val);
+    });
+
+#    ifdef PYBIND11_HAS_U8STRING
+    m.def("string_view8_print", [](std::u8string_view s) { py::print(s, s.size()); });
+    m.def("string_view8_chars", [](std::u8string_view s) {
+        py::list l;
+        for (auto c : s)
+            l.append((std::uint8_t) c);
+        return l;
+    });
+    m.def("string_view8_return", []() { return std::u8string_view(u8"utf8 secret \U0001f382"); });
+    m.def("string_view8_str", []() { return py::str{std::u8string_view{u8"abc ‽ def"}}; });
+#    endif
+
+    struct TypeWithBothOperatorStringAndStringView {
+        // NOLINTNEXTLINE(google-explicit-constructor)
+        operator std::string() const { return "success"; }
+        // NOLINTNEXTLINE(google-explicit-constructor)
+        operator std::string_view() const { return "failure"; }
+    };
+    m.def("bytes_from_type_with_both_operator_string_and_string_view",
+          []() { return py::bytes(TypeWithBothOperatorStringAndStringView()); });
+    m.def("str_from_type_with_both_operator_string_and_string_view",
+          []() { return py::str(TypeWithBothOperatorStringAndStringView()); });
+#endif
+
+    // test_integer_casting
+    m.def("i32_str", [](std::int32_t v) { return std::to_string(v); });
+    m.def("u32_str", [](std::uint32_t v) { return std::to_string(v); });
+    m.def("i64_str", [](std::int64_t v) { return std::to_string(v); });
+    m.def("u64_str", [](std::uint64_t v) { return std::to_string(v); });
+
+    // test_int_convert
+    m.def("int_passthrough", [](int arg) { return arg; });
+    m.def(
+        "int_passthrough_noconvert", [](int arg) { return arg; }, py::arg{}.noconvert());
+
+    // test_tuple
+    m.def(
+        "pair_passthrough",
+        [](const std::pair<bool, std::string> &input) {
+            return std::make_pair(input.second, input.first);
+        },
+        "Return a pair in reversed order");
+    m.def(
+        "tuple_passthrough",
+        [](std::tuple<bool, std::string, int> input) {
+            return std::make_tuple(std::get<2>(input), std::get<1>(input), std::get<0>(input));
+        },
+        "Return a triple in reversed order");
+    m.def("empty_tuple", []() { return std::tuple<>(); });
+    static std::pair<RValueCaster, RValueCaster> lvpair;
+    static std::tuple<RValueCaster, RValueCaster, RValueCaster> lvtuple;
+    static std::pair<RValueCaster, std::tuple<RValueCaster, std::pair<RValueCaster, RValueCaster>>>
+        lvnested;
+    m.def("rvalue_pair", []() { return std::make_pair(RValueCaster{}, RValueCaster{}); });
+    m.def("lvalue_pair", []() -> const decltype(lvpair) & { return lvpair; });
+    m.def("rvalue_tuple",
+          []() { return std::make_tuple(RValueCaster{}, RValueCaster{}, RValueCaster{}); });
+    m.def("lvalue_tuple", []() -> const decltype(lvtuple) & { return lvtuple; });
+    m.def("rvalue_nested", []() {
+        return std::make_pair(
+            RValueCaster{},
+            std::make_tuple(RValueCaster{}, std::make_pair(RValueCaster{}, RValueCaster{})));
+    });
+    m.def("lvalue_nested", []() -> const decltype(lvnested) & { return lvnested; });
+
+    m.def(
+        "int_string_pair",
+        []() {
+            // Using no-destructor idiom to side-step warnings from overzealous compilers.
+            static auto *int_string_pair = new std::pair<int, std::string>{2, "items"};
+            return int_string_pair;
+        },
+        py::return_value_policy::reference);
+
+    // test_builtins_cast_return_none
+    m.def("return_none_string", []() -> std::string * { return nullptr; });
+    m.def("return_none_char", []() -> const char * { return nullptr; });
+    m.def("return_none_bool", []() -> bool * { return nullptr; });
+    m.def("return_none_int", []() -> int * { return nullptr; });
+    m.def("return_none_float", []() -> float * { return nullptr; });
+    m.def("return_none_pair", []() -> std::pair<int, int> * { return nullptr; });
+
+    // test_none_deferred
+    m.def("defer_none_cstring", [](char *) { return false; });
+    m.def("defer_none_cstring", [](const py::none &) { return true; });
+    m.def("defer_none_custom", [](UserType *) { return false; });
+    m.def("defer_none_custom", [](const py::none &) { return true; });
+    m.def("nodefer_none_void", [](void *) { return true; });
+    m.def("nodefer_none_void", [](const py::none &) { return false; });
+
+    // test_void_caster
+    m.def("load_nullptr_t", [](std::nullptr_t) {}); // not useful, but it should still compile
+    m.def("cast_nullptr_t", []() { return std::nullptr_t{}; });
+
+    // [workaround(intel)] ICC 20/21 breaks with py::arg().stuff, using py::arg{}.stuff works.
+
+    // test_bool_caster
+    m.def("bool_passthrough", [](bool arg) { return arg; });
+    m.def(
+        "bool_passthrough_noconvert", [](bool arg) { return arg; }, py::arg{}.noconvert());
+
+    // TODO: This should be disabled and fixed in future Intel compilers
+#if !defined(__INTEL_COMPILER)
+    // Test "bool_passthrough_noconvert" again, but using () instead of {} to construct py::arg
+    // When compiled with the Intel compiler, this results in segmentation faults when importing
+    // the module. Tested with icc (ICC) 2021.1 Beta 20200827, this should be tested again when
+    // a newer version of icc is available.
+    m.def(
+        "bool_passthrough_noconvert2", [](bool arg) { return arg; }, py::arg().noconvert());
+#endif
+
+    // test_reference_wrapper
+    m.def("refwrap_builtin", [](std::reference_wrapper<int> p) { return 10 * p.get(); });
+    m.def("refwrap_usertype", [](std::reference_wrapper<UserType> p) { return p.get().value(); });
+    m.def("refwrap_usertype_const",
+          [](std::reference_wrapper<const UserType> p) { return p.get().value(); });
+
+    m.def("refwrap_lvalue", []() -> std::reference_wrapper<UserType> {
+        static UserType x(1);
+        return std::ref(x);
+    });
+    m.def("refwrap_lvalue_const", []() -> std::reference_wrapper<const UserType> {
+        static UserType x(1);
+        return std::cref(x);
+    });
+
+    // Not currently supported (std::pair caster has return-by-value cast operator);
+    // triggers static_assert failure.
+    // m.def("refwrap_pair", [](std::reference_wrapper<std::pair<int, int>>) { });
+
+    m.def(
+        "refwrap_list",
+        [](bool copy) {
+            static IncType x1(1), x2(2);
+            py::list l;
+            for (const auto &f : {std::ref(x1), std::ref(x2)}) {
+                l.append(py::cast(
+                    f, copy ? py::return_value_policy::copy : py::return_value_policy::reference));
+            }
+            return l;
+        },
+        "copy"_a);
+
+    m.def("refwrap_iiw", [](const IncType &w) { return w.value(); });
+    m.def("refwrap_call_iiw", [](IncType &w, const py::function &f) {
+        py::list l;
+        l.append(f(std::ref(w)));
+        l.append(f(std::cref(w)));
+        IncType x(w.value());
+        l.append(f(std::ref(x)));
+        IncType y(w.value());
+        auto r3 = std::ref(y);
+        l.append(f(r3));
+        return l;
+    });
+
+    // test_complex
+    m.def("complex_cast", [](float x) { return "{}"_s.format(x); });
+    m.def("complex_cast",
+          [](std::complex<float> x) { return "({}, {})"_s.format(x.real(), x.imag()); });
+
+    // test int vs. long (Python 2)
+    m.def("int_cast", []() { return (int) 42; });
+    m.def("long_cast", []() { return (long) 42; });
+    m.def("longlong_cast", []() { return ULLONG_MAX; });
+
+    /// test void* cast operator
+    m.def("test_void_caster", []() -> bool {
+        void *v = (void *) 0xabcd;
+        py::object o = py::cast(v);
+        return py::cast<void *>(o) == v;
+    });
+
+    // Tests const/non-const propagation in cast_op.
+    m.def("takes", [](ConstRefCasted x) { return x.tag; });
+    m.def("takes_move", [](ConstRefCasted &&x) { return x.tag; });
+    m.def("takes_ptr", [](ConstRefCasted *x) { return x->tag; });
+    m.def("takes_ref", [](ConstRefCasted &x) { return x.tag; });
+    m.def("takes_ref_wrap", [](std::reference_wrapper<ConstRefCasted> x) { return x.get().tag; });
+    m.def("takes_const_ptr", [](const ConstRefCasted *x) { return x->tag; });
+    m.def("takes_const_ref", [](const ConstRefCasted &x) { return x.tag; });
+    m.def("takes_const_ref_wrap",
+          [](std::reference_wrapper<const ConstRefCasted> x) { return x.get().tag; });
+
+    PYBIND11_WARNING_POP
+}

third_party/CityFlow/extern/pybind11/tests/test_builtin_casters.py

@@ -1,528 +1,528 @@
-import sys
-
-import pytest
-
-import env
-from pybind11_tests import IncType, UserType
-from pybind11_tests import builtin_casters as m
-
-
-def test_simple_string():
-    assert m.string_roundtrip("const char *") == "const char *"
-
-
-def test_unicode_conversion():
-    """Tests unicode conversion and error reporting."""
-    assert m.good_utf8_string() == "Say utf8‽ 🎂 𝐀"
-    assert m.good_utf16_string() == "b‽🎂𝐀z"
-    assert m.good_utf32_string() == "a𝐀🎂‽z"
-    assert m.good_wchar_string() == "a⸘𝐀z"
-    if hasattr(m, "has_u8string"):
-        assert m.good_utf8_u8string() == "Say utf8‽ 🎂 𝐀"
-
-    with pytest.raises(UnicodeDecodeError):
-        m.bad_utf8_string()
-
-    with pytest.raises(UnicodeDecodeError):
-        m.bad_utf16_string()
-
-    # These are provided only if they actually fail (they don't when 32-bit)
-    if hasattr(m, "bad_utf32_string"):
-        with pytest.raises(UnicodeDecodeError):
-            m.bad_utf32_string()
-    if hasattr(m, "bad_wchar_string"):
-        with pytest.raises(UnicodeDecodeError):
-            m.bad_wchar_string()
-    if hasattr(m, "has_u8string"):
-        with pytest.raises(UnicodeDecodeError):
-            m.bad_utf8_u8string()
-
-    assert m.u8_Z() == "Z"
-    assert m.u8_eacute() == "é"
-    assert m.u16_ibang() == "‽"
-    assert m.u32_mathbfA() == "𝐀"
-    assert m.wchar_heart() == "♥"
-    if hasattr(m, "has_u8string"):
-        assert m.u8_char8_Z() == "Z"
-
-
-def test_single_char_arguments():
-    """Tests failures for passing invalid inputs to char-accepting functions"""
-
-    def toobig_message(r):
-        return f"Character code point not in range({r:#x})"
-
-    toolong_message = "Expected a character, but multi-character string found"
-
-    assert m.ord_char("a") == 0x61  # simple ASCII
-    assert m.ord_char_lv("b") == 0x62
-    assert (
-        m.ord_char("é") == 0xE9
-    )  # requires 2 bytes in utf-8, but can be stuffed in a char
-    with pytest.raises(ValueError) as excinfo:
-        assert m.ord_char("Ā") == 0x100  # requires 2 bytes, doesn't fit in a char
-    assert str(excinfo.value) == toobig_message(0x100)
-    with pytest.raises(ValueError) as excinfo:
-        assert m.ord_char("ab")
-    assert str(excinfo.value) == toolong_message
-
-    assert m.ord_char16("a") == 0x61
-    assert m.ord_char16("é") == 0xE9
-    assert m.ord_char16_lv("ê") == 0xEA
-    assert m.ord_char16("Ā") == 0x100
-    assert m.ord_char16("‽") == 0x203D
-    assert m.ord_char16("♥") == 0x2665
-    assert m.ord_char16_lv("♡") == 0x2661
-    with pytest.raises(ValueError) as excinfo:
-        assert m.ord_char16("🎂") == 0x1F382  # requires surrogate pair
-    assert str(excinfo.value) == toobig_message(0x10000)
-    with pytest.raises(ValueError) as excinfo:
-        assert m.ord_char16("aa")
-    assert str(excinfo.value) == toolong_message
-
-    assert m.ord_char32("a") == 0x61
-    assert m.ord_char32("é") == 0xE9
-    assert m.ord_char32("Ā") == 0x100
-    assert m.ord_char32("‽") == 0x203D
-    assert m.ord_char32("♥") == 0x2665
-    assert m.ord_char32("🎂") == 0x1F382
-    with pytest.raises(ValueError) as excinfo:
-        assert m.ord_char32("aa")
-    assert str(excinfo.value) == toolong_message
-
-    assert m.ord_wchar("a") == 0x61
-    assert m.ord_wchar("é") == 0xE9
-    assert m.ord_wchar("Ā") == 0x100
-    assert m.ord_wchar("‽") == 0x203D
-    assert m.ord_wchar("♥") == 0x2665
-    if m.wchar_size == 2:
-        with pytest.raises(ValueError) as excinfo:
-            assert m.ord_wchar("🎂") == 0x1F382  # requires surrogate pair
-        assert str(excinfo.value) == toobig_message(0x10000)
-    else:
-        assert m.ord_wchar("🎂") == 0x1F382
-    with pytest.raises(ValueError) as excinfo:
-        assert m.ord_wchar("aa")
-    assert str(excinfo.value) == toolong_message
-
-    if hasattr(m, "has_u8string"):
-        assert m.ord_char8("a") == 0x61  # simple ASCII
-        assert m.ord_char8_lv("b") == 0x62
-        assert (
-            m.ord_char8("é") == 0xE9
-        )  # requires 2 bytes in utf-8, but can be stuffed in a char
-        with pytest.raises(ValueError) as excinfo:
-            assert m.ord_char8("Ā") == 0x100  # requires 2 bytes, doesn't fit in a char
-        assert str(excinfo.value) == toobig_message(0x100)
-        with pytest.raises(ValueError) as excinfo:
-            assert m.ord_char8("ab")
-        assert str(excinfo.value) == toolong_message
-
-
-def test_bytes_to_string():
-    """Tests the ability to pass bytes to C++ string-accepting functions.  Note that this is
-    one-way: the only way to return bytes to Python is via the pybind11::bytes class."""
-    # Issue #816
-
-    assert m.strlen(b"hi") == 2
-    assert m.string_length(b"world") == 5
-    assert m.string_length(b"a\x00b") == 3
-    assert m.strlen(b"a\x00b") == 1  # C-string limitation
-
-    # passing in a utf8 encoded string should work
-    assert m.string_length("💩".encode()) == 4
-
-
-def test_bytearray_to_string():
-    """Tests the ability to pass bytearray to C++ string-accepting functions"""
-    assert m.string_length(bytearray(b"Hi")) == 2
-    assert m.strlen(bytearray(b"bytearray")) == 9
-    assert m.string_length(bytearray()) == 0
-    assert m.string_length(bytearray("🦜", "utf-8", "strict")) == 4
-    assert m.string_length(bytearray(b"\x80")) == 1
-
-
-@pytest.mark.skipif(not hasattr(m, "has_string_view"), reason="no <string_view>")
-def test_string_view(capture):
-    """Tests support for C++17 string_view arguments and return values"""
-    assert m.string_view_chars("Hi") == [72, 105]
-    assert m.string_view_chars("Hi 🎂") == [72, 105, 32, 0xF0, 0x9F, 0x8E, 0x82]
-    assert m.string_view16_chars("Hi 🎂") == [72, 105, 32, 0xD83C, 0xDF82]
-    assert m.string_view32_chars("Hi 🎂") == [72, 105, 32, 127874]
-    if hasattr(m, "has_u8string"):
-        assert m.string_view8_chars("Hi") == [72, 105]
-        assert m.string_view8_chars("Hi 🎂") == [72, 105, 32, 0xF0, 0x9F, 0x8E, 0x82]
-
-    assert m.string_view_return() == "utf8 secret 🎂"
-    assert m.string_view16_return() == "utf16 secret 🎂"
-    assert m.string_view32_return() == "utf32 secret 🎂"
-    if hasattr(m, "has_u8string"):
-        assert m.string_view8_return() == "utf8 secret 🎂"
-
-    with capture:
-        m.string_view_print("Hi")
-        m.string_view_print("utf8 🎂")
-        m.string_view16_print("utf16 🎂")
-        m.string_view32_print("utf32 🎂")
-    assert (
-        capture
-        == """
-        Hi 2
-        utf8 🎂 9
-        utf16 🎂 8
-        utf32 🎂 7
-    """
-    )
-    if hasattr(m, "has_u8string"):
-        with capture:
-            m.string_view8_print("Hi")
-            m.string_view8_print("utf8 🎂")
-        assert (
-            capture
-            == """
-            Hi 2
-            utf8 🎂 9
-        """
-        )
-
-    with capture:
-        m.string_view_print("Hi, ascii")
-        m.string_view_print("Hi, utf8 🎂")
-        m.string_view16_print("Hi, utf16 🎂")
-        m.string_view32_print("Hi, utf32 🎂")
-    assert (
-        capture
-        == """
-        Hi, ascii 9
-        Hi, utf8 🎂 13
-        Hi, utf16 🎂 12
-        Hi, utf32 🎂 11
-    """
-    )
-    if hasattr(m, "has_u8string"):
-        with capture:
-            m.string_view8_print("Hi, ascii")
-            m.string_view8_print("Hi, utf8 🎂")
-        assert (
-            capture
-            == """
-            Hi, ascii 9
-            Hi, utf8 🎂 13
-        """
-        )
-
-    assert m.string_view_bytes() == b"abc \x80\x80 def"
-    assert m.string_view_str() == "abc ‽ def"
-    assert m.string_view_from_bytes("abc ‽ def".encode()) == "abc ‽ def"
-    if hasattr(m, "has_u8string"):
-        assert m.string_view8_str() == "abc ‽ def"
-    assert m.string_view_memoryview() == "Have some 🎂".encode()
-
-    assert m.bytes_from_type_with_both_operator_string_and_string_view() == b"success"
-    assert m.str_from_type_with_both_operator_string_and_string_view() == "success"
-
-
-def test_integer_casting():
-    """Issue #929 - out-of-range integer values shouldn't be accepted"""
-    assert m.i32_str(-1) == "-1"
-    assert m.i64_str(-1) == "-1"
-    assert m.i32_str(2000000000) == "2000000000"
-    assert m.u32_str(2000000000) == "2000000000"
-    assert m.i64_str(-999999999999) == "-999999999999"
-    assert m.u64_str(999999999999) == "999999999999"
-
-    with pytest.raises(TypeError) as excinfo:
-        m.u32_str(-1)
-    assert "incompatible function arguments" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.u64_str(-1)
-    assert "incompatible function arguments" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.i32_str(-3000000000)
-    assert "incompatible function arguments" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.i32_str(3000000000)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test_int_convert():
-    class Int:
-        def __int__(self):
-            return 42
-
-    class NotInt:
-        pass
-
-    class Float:
-        def __float__(self):
-            return 41.99999
-
-    class Index:
-        def __index__(self):
-            return 42
-
-    class IntAndIndex:
-        def __int__(self):
-            return 42
-
-        def __index__(self):
-            return 0
-
-    class RaisingTypeErrorOnIndex:
-        def __index__(self):
-            raise TypeError
-
-        def __int__(self):
-            return 42
-
-    class RaisingValueErrorOnIndex:
-        def __index__(self):
-            raise ValueError
-
-        def __int__(self):
-            return 42
-
-    convert, noconvert = m.int_passthrough, m.int_passthrough_noconvert
-
-    def requires_conversion(v):
-        pytest.raises(TypeError, noconvert, v)
-
-    def cant_convert(v):
-        pytest.raises(TypeError, convert, v)
-
-    assert convert(7) == 7
-    assert noconvert(7) == 7
-    cant_convert(3.14159)
-    # TODO: Avoid DeprecationWarning in `PyLong_AsLong` (and similar)
-    # TODO: PyPy 3.8 does not behave like CPython 3.8 here yet (7.3.7)
-    if (3, 8) <= sys.version_info < (3, 10) and env.CPYTHON:
-        with env.deprecated_call():
-            assert convert(Int()) == 42
-    else:
-        assert convert(Int()) == 42
-    requires_conversion(Int())
-    cant_convert(NotInt())
-    cant_convert(Float())
-
-    # Before Python 3.8, `PyLong_AsLong` does not pick up on `obj.__index__`,
-    # but pybind11 "backports" this behavior.
-    assert convert(Index()) == 42
-    assert noconvert(Index()) == 42
-    assert convert(IntAndIndex()) == 0  # Fishy; `int(DoubleThought)` == 42
-    assert noconvert(IntAndIndex()) == 0
-    assert convert(RaisingTypeErrorOnIndex()) == 42
-    requires_conversion(RaisingTypeErrorOnIndex())
-    assert convert(RaisingValueErrorOnIndex()) == 42
-    requires_conversion(RaisingValueErrorOnIndex())
-
-
-def test_numpy_int_convert():
-    np = pytest.importorskip("numpy")
-
-    convert, noconvert = m.int_passthrough, m.int_passthrough_noconvert
-
-    def require_implicit(v):
-        pytest.raises(TypeError, noconvert, v)
-
-    # `np.intc` is an alias that corresponds to a C++ `int`
-    assert convert(np.intc(42)) == 42
-    assert noconvert(np.intc(42)) == 42
-
-    # The implicit conversion from np.float32 is undesirable but currently accepted.
-    # TODO: Avoid DeprecationWarning in `PyLong_AsLong` (and similar)
-    # TODO: PyPy 3.8 does not behave like CPython 3.8 here yet (7.3.7)
-    # https://github.com/pybind/pybind11/issues/3408
-    if (3, 8) <= sys.version_info < (3, 10) and env.CPYTHON:
-        with env.deprecated_call():
-            assert convert(np.float32(3.14159)) == 3
-    else:
-        assert convert(np.float32(3.14159)) == 3
-    require_implicit(np.float32(3.14159))
-
-
-def test_tuple(doc):
-    """std::pair <-> tuple & std::tuple <-> tuple"""
-    assert m.pair_passthrough((True, "test")) == ("test", True)
-    assert m.tuple_passthrough((True, "test", 5)) == (5, "test", True)
-    # Any sequence can be cast to a std::pair or std::tuple
-    assert m.pair_passthrough([True, "test"]) == ("test", True)
-    assert m.tuple_passthrough([True, "test", 5]) == (5, "test", True)
-    assert m.empty_tuple() == ()
-
-    assert (
-        doc(m.pair_passthrough)
-        == """
-        pair_passthrough(arg0: tuple[bool, str]) -> tuple[str, bool]
-
-        Return a pair in reversed order
-    """
-    )
-    assert (
-        doc(m.tuple_passthrough)
-        == """
-        tuple_passthrough(arg0: tuple[bool, str, int]) -> tuple[int, str, bool]
-
-        Return a triple in reversed order
-    """
-    )
-
-    assert m.rvalue_pair() == ("rvalue", "rvalue")
-    assert m.lvalue_pair() == ("lvalue", "lvalue")
-    assert m.rvalue_tuple() == ("rvalue", "rvalue", "rvalue")
-    assert m.lvalue_tuple() == ("lvalue", "lvalue", "lvalue")
-    assert m.rvalue_nested() == ("rvalue", ("rvalue", ("rvalue", "rvalue")))
-    assert m.lvalue_nested() == ("lvalue", ("lvalue", ("lvalue", "lvalue")))
-
-    assert m.int_string_pair() == (2, "items")
-
-
-def test_builtins_cast_return_none():
-    """Casters produced with PYBIND11_TYPE_CASTER() should convert nullptr to None"""
-    assert m.return_none_string() is None
-    assert m.return_none_char() is None
-    assert m.return_none_bool() is None
-    assert m.return_none_int() is None
-    assert m.return_none_float() is None
-    assert m.return_none_pair() is None
-
-
-def test_none_deferred():
-    """None passed as various argument types should defer to other overloads"""
-    assert not m.defer_none_cstring("abc")
-    assert m.defer_none_cstring(None)
-    assert not m.defer_none_custom(UserType())
-    assert m.defer_none_custom(None)
-    assert m.nodefer_none_void(None)
-
-
-def test_void_caster():
-    assert m.load_nullptr_t(None) is None
-    assert m.cast_nullptr_t() is None
-
-
-def test_reference_wrapper():
-    """std::reference_wrapper for builtin and user types"""
-    assert m.refwrap_builtin(42) == 420
-    assert m.refwrap_usertype(UserType(42)) == 42
-    assert m.refwrap_usertype_const(UserType(42)) == 42
-
-    with pytest.raises(TypeError) as excinfo:
-        m.refwrap_builtin(None)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.refwrap_usertype(None)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    assert m.refwrap_lvalue().value == 1
-    assert m.refwrap_lvalue_const().value == 1
-
-    a1 = m.refwrap_list(copy=True)
-    a2 = m.refwrap_list(copy=True)
-    assert [x.value for x in a1] == [2, 3]
-    assert [x.value for x in a2] == [2, 3]
-    assert a1[0] is not a2[0]
-    assert a1[1] is not a2[1]
-
-    b1 = m.refwrap_list(copy=False)
-    b2 = m.refwrap_list(copy=False)
-    assert [x.value for x in b1] == [1, 2]
-    assert [x.value for x in b2] == [1, 2]
-    assert b1[0] is b2[0]
-    assert b1[1] is b2[1]
-
-    assert m.refwrap_iiw(IncType(5)) == 5
-    assert m.refwrap_call_iiw(IncType(10), m.refwrap_iiw) == [10, 10, 10, 10]
-
-
-def test_complex_cast():
-    """std::complex casts"""
-    assert m.complex_cast(1) == "1.0"
-    assert m.complex_cast(2j) == "(0.0, 2.0)"
-
-
-def test_bool_caster():
-    """Test bool caster implicit conversions."""
-    convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert
-
-    def require_implicit(v):
-        pytest.raises(TypeError, noconvert, v)
-
-    def cant_convert(v):
-        pytest.raises(TypeError, convert, v)
-
-    # straight up bool
-    assert convert(True) is True
-    assert convert(False) is False
-    assert noconvert(True) is True
-    assert noconvert(False) is False
-
-    # None requires implicit conversion
-    require_implicit(None)
-    assert convert(None) is False
-
-    class A:
-        def __init__(self, x):
-            self.x = x
-
-        def __nonzero__(self):
-            return self.x
-
-        def __bool__(self):
-            return self.x
-
-    class B:
-        pass
-
-    # Arbitrary objects are not accepted
-    cant_convert(object())
-    cant_convert(B())
-
-    # Objects with __nonzero__ / __bool__ defined can be converted
-    require_implicit(A(True))
-    assert convert(A(True)) is True
-    assert convert(A(False)) is False
-
-
-def test_numpy_bool():
-    np = pytest.importorskip("numpy")
-
-    convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert
-
-    def cant_convert(v):
-        pytest.raises(TypeError, convert, v)
-
-    # np.bool_ is not considered implicit
-    assert convert(np.bool_(True)) is True
-    assert convert(np.bool_(False)) is False
-    assert noconvert(np.bool_(True)) is True
-    assert noconvert(np.bool_(False)) is False
-    cant_convert(np.zeros(2, dtype="int"))
-
-
-def test_int_long():
-    assert isinstance(m.int_cast(), int)
-    assert isinstance(m.long_cast(), int)
-    assert isinstance(m.longlong_cast(), int)
-
-
-def test_void_caster_2():
-    assert m.test_void_caster()
-
-
-def test_const_ref_caster():
-    """Verifies that const-ref is propagated through type_caster cast_op.
-    The returned ConstRefCasted type is a minimal type that is constructed to
-    reference the casting mode used.
-    """
-    x = False
-    assert m.takes(x) == 1
-    assert m.takes_move(x) == 1
-
-    assert m.takes_ptr(x) == 3
-    assert m.takes_ref(x) == 2
-    assert m.takes_ref_wrap(x) == 2
-
-    assert m.takes_const_ptr(x) == 5
-    assert m.takes_const_ref(x) == 4
-    assert m.takes_const_ref_wrap(x) == 4
+import sys
+
+import pytest
+
+import env
+from pybind11_tests import IncType, UserType
+from pybind11_tests import builtin_casters as m
+
+
+def test_simple_string():
+    assert m.string_roundtrip("const char *") == "const char *"
+
+
+def test_unicode_conversion():
+    """Tests unicode conversion and error reporting."""
+    assert m.good_utf8_string() == "Say utf8‽ 🎂 𝐀"
+    assert m.good_utf16_string() == "b‽🎂𝐀z"
+    assert m.good_utf32_string() == "a𝐀🎂‽z"
+    assert m.good_wchar_string() == "a⸘𝐀z"
+    if hasattr(m, "has_u8string"):
+        assert m.good_utf8_u8string() == "Say utf8‽ 🎂 𝐀"
+
+    with pytest.raises(UnicodeDecodeError):
+        m.bad_utf8_string()
+
+    with pytest.raises(UnicodeDecodeError):
+        m.bad_utf16_string()
+
+    # These are provided only if they actually fail (they don't when 32-bit)
+    if hasattr(m, "bad_utf32_string"):
+        with pytest.raises(UnicodeDecodeError):
+            m.bad_utf32_string()
+    if hasattr(m, "bad_wchar_string"):
+        with pytest.raises(UnicodeDecodeError):
+            m.bad_wchar_string()
+    if hasattr(m, "has_u8string"):
+        with pytest.raises(UnicodeDecodeError):
+            m.bad_utf8_u8string()
+
+    assert m.u8_Z() == "Z"
+    assert m.u8_eacute() == "é"
+    assert m.u16_ibang() == "‽"
+    assert m.u32_mathbfA() == "𝐀"
+    assert m.wchar_heart() == "♥"
+    if hasattr(m, "has_u8string"):
+        assert m.u8_char8_Z() == "Z"
+
+
+def test_single_char_arguments():
+    """Tests failures for passing invalid inputs to char-accepting functions"""
+
+    def toobig_message(r):
+        return f"Character code point not in range({r:#x})"
+
+    toolong_message = "Expected a character, but multi-character string found"
+
+    assert m.ord_char("a") == 0x61  # simple ASCII
+    assert m.ord_char_lv("b") == 0x62
+    assert (
+        m.ord_char("é") == 0xE9
+    )  # requires 2 bytes in utf-8, but can be stuffed in a char
+    with pytest.raises(ValueError) as excinfo:
+        assert m.ord_char("Ā") == 0x100  # requires 2 bytes, doesn't fit in a char
+    assert str(excinfo.value) == toobig_message(0x100)
+    with pytest.raises(ValueError) as excinfo:
+        assert m.ord_char("ab")
+    assert str(excinfo.value) == toolong_message
+
+    assert m.ord_char16("a") == 0x61
+    assert m.ord_char16("é") == 0xE9
+    assert m.ord_char16_lv("ê") == 0xEA
+    assert m.ord_char16("Ā") == 0x100
+    assert m.ord_char16("‽") == 0x203D
+    assert m.ord_char16("♥") == 0x2665
+    assert m.ord_char16_lv("♡") == 0x2661
+    with pytest.raises(ValueError) as excinfo:
+        assert m.ord_char16("🎂") == 0x1F382  # requires surrogate pair
+    assert str(excinfo.value) == toobig_message(0x10000)
+    with pytest.raises(ValueError) as excinfo:
+        assert m.ord_char16("aa")
+    assert str(excinfo.value) == toolong_message
+
+    assert m.ord_char32("a") == 0x61
+    assert m.ord_char32("é") == 0xE9
+    assert m.ord_char32("Ā") == 0x100
+    assert m.ord_char32("‽") == 0x203D
+    assert m.ord_char32("♥") == 0x2665
+    assert m.ord_char32("🎂") == 0x1F382
+    with pytest.raises(ValueError) as excinfo:
+        assert m.ord_char32("aa")
+    assert str(excinfo.value) == toolong_message
+
+    assert m.ord_wchar("a") == 0x61
+    assert m.ord_wchar("é") == 0xE9
+    assert m.ord_wchar("Ā") == 0x100
+    assert m.ord_wchar("‽") == 0x203D
+    assert m.ord_wchar("♥") == 0x2665
+    if m.wchar_size == 2:
+        with pytest.raises(ValueError) as excinfo:
+            assert m.ord_wchar("🎂") == 0x1F382  # requires surrogate pair
+        assert str(excinfo.value) == toobig_message(0x10000)
+    else:
+        assert m.ord_wchar("🎂") == 0x1F382
+    with pytest.raises(ValueError) as excinfo:
+        assert m.ord_wchar("aa")
+    assert str(excinfo.value) == toolong_message
+
+    if hasattr(m, "has_u8string"):
+        assert m.ord_char8("a") == 0x61  # simple ASCII
+        assert m.ord_char8_lv("b") == 0x62
+        assert (
+            m.ord_char8("é") == 0xE9
+        )  # requires 2 bytes in utf-8, but can be stuffed in a char
+        with pytest.raises(ValueError) as excinfo:
+            assert m.ord_char8("Ā") == 0x100  # requires 2 bytes, doesn't fit in a char
+        assert str(excinfo.value) == toobig_message(0x100)
+        with pytest.raises(ValueError) as excinfo:
+            assert m.ord_char8("ab")
+        assert str(excinfo.value) == toolong_message
+
+
+def test_bytes_to_string():
+    """Tests the ability to pass bytes to C++ string-accepting functions.  Note that this is
+    one-way: the only way to return bytes to Python is via the pybind11::bytes class."""
+    # Issue #816
+
+    assert m.strlen(b"hi") == 2
+    assert m.string_length(b"world") == 5
+    assert m.string_length(b"a\x00b") == 3
+    assert m.strlen(b"a\x00b") == 1  # C-string limitation
+
+    # passing in a utf8 encoded string should work
+    assert m.string_length("💩".encode()) == 4
+
+
+def test_bytearray_to_string():
+    """Tests the ability to pass bytearray to C++ string-accepting functions"""
+    assert m.string_length(bytearray(b"Hi")) == 2
+    assert m.strlen(bytearray(b"bytearray")) == 9
+    assert m.string_length(bytearray()) == 0
+    assert m.string_length(bytearray("🦜", "utf-8", "strict")) == 4
+    assert m.string_length(bytearray(b"\x80")) == 1
+
+
+@pytest.mark.skipif(not hasattr(m, "has_string_view"), reason="no <string_view>")
+def test_string_view(capture):
+    """Tests support for C++17 string_view arguments and return values"""
+    assert m.string_view_chars("Hi") == [72, 105]
+    assert m.string_view_chars("Hi 🎂") == [72, 105, 32, 0xF0, 0x9F, 0x8E, 0x82]
+    assert m.string_view16_chars("Hi 🎂") == [72, 105, 32, 0xD83C, 0xDF82]
+    assert m.string_view32_chars("Hi 🎂") == [72, 105, 32, 127874]
+    if hasattr(m, "has_u8string"):
+        assert m.string_view8_chars("Hi") == [72, 105]
+        assert m.string_view8_chars("Hi 🎂") == [72, 105, 32, 0xF0, 0x9F, 0x8E, 0x82]
+
+    assert m.string_view_return() == "utf8 secret 🎂"
+    assert m.string_view16_return() == "utf16 secret 🎂"
+    assert m.string_view32_return() == "utf32 secret 🎂"
+    if hasattr(m, "has_u8string"):
+        assert m.string_view8_return() == "utf8 secret 🎂"
+
+    with capture:
+        m.string_view_print("Hi")
+        m.string_view_print("utf8 🎂")
+        m.string_view16_print("utf16 🎂")
+        m.string_view32_print("utf32 🎂")
+    assert (
+        capture
+        == """
+        Hi 2
+        utf8 🎂 9
+        utf16 🎂 8
+        utf32 🎂 7
+    """
+    )
+    if hasattr(m, "has_u8string"):
+        with capture:
+            m.string_view8_print("Hi")
+            m.string_view8_print("utf8 🎂")
+        assert (
+            capture
+            == """
+            Hi 2
+            utf8 🎂 9
+        """
+        )
+
+    with capture:
+        m.string_view_print("Hi, ascii")
+        m.string_view_print("Hi, utf8 🎂")
+        m.string_view16_print("Hi, utf16 🎂")
+        m.string_view32_print("Hi, utf32 🎂")
+    assert (
+        capture
+        == """
+        Hi, ascii 9
+        Hi, utf8 🎂 13
+        Hi, utf16 🎂 12
+        Hi, utf32 🎂 11
+    """
+    )
+    if hasattr(m, "has_u8string"):
+        with capture:
+            m.string_view8_print("Hi, ascii")
+            m.string_view8_print("Hi, utf8 🎂")
+        assert (
+            capture
+            == """
+            Hi, ascii 9
+            Hi, utf8 🎂 13
+        """
+        )
+
+    assert m.string_view_bytes() == b"abc \x80\x80 def"
+    assert m.string_view_str() == "abc ‽ def"
+    assert m.string_view_from_bytes("abc ‽ def".encode()) == "abc ‽ def"
+    if hasattr(m, "has_u8string"):
+        assert m.string_view8_str() == "abc ‽ def"
+    assert m.string_view_memoryview() == "Have some 🎂".encode()
+
+    assert m.bytes_from_type_with_both_operator_string_and_string_view() == b"success"
+    assert m.str_from_type_with_both_operator_string_and_string_view() == "success"
+
+
+def test_integer_casting():
+    """Issue #929 - out-of-range integer values shouldn't be accepted"""
+    assert m.i32_str(-1) == "-1"
+    assert m.i64_str(-1) == "-1"
+    assert m.i32_str(2000000000) == "2000000000"
+    assert m.u32_str(2000000000) == "2000000000"
+    assert m.i64_str(-999999999999) == "-999999999999"
+    assert m.u64_str(999999999999) == "999999999999"
+
+    with pytest.raises(TypeError) as excinfo:
+        m.u32_str(-1)
+    assert "incompatible function arguments" in str(excinfo.value)
+    with pytest.raises(TypeError) as excinfo:
+        m.u64_str(-1)
+    assert "incompatible function arguments" in str(excinfo.value)
+    with pytest.raises(TypeError) as excinfo:
+        m.i32_str(-3000000000)
+    assert "incompatible function arguments" in str(excinfo.value)
+    with pytest.raises(TypeError) as excinfo:
+        m.i32_str(3000000000)
+    assert "incompatible function arguments" in str(excinfo.value)
+
+
+def test_int_convert():
+    class Int:
+        def __int__(self):
+            return 42
+
+    class NotInt:
+        pass
+
+    class Float:
+        def __float__(self):
+            return 41.99999
+
+    class Index:
+        def __index__(self):
+            return 42
+
+    class IntAndIndex:
+        def __int__(self):
+            return 42
+
+        def __index__(self):
+            return 0
+
+    class RaisingTypeErrorOnIndex:
+        def __index__(self):
+            raise TypeError
+
+        def __int__(self):
+            return 42
+
+    class RaisingValueErrorOnIndex:
+        def __index__(self):
+            raise ValueError
+
+        def __int__(self):
+            return 42
+
+    convert, noconvert = m.int_passthrough, m.int_passthrough_noconvert
+
+    def requires_conversion(v):
+        pytest.raises(TypeError, noconvert, v)
+
+    def cant_convert(v):
+        pytest.raises(TypeError, convert, v)
+
+    assert convert(7) == 7
+    assert noconvert(7) == 7
+    cant_convert(3.14159)
+    # TODO: Avoid DeprecationWarning in `PyLong_AsLong` (and similar)
+    # TODO: PyPy 3.8 does not behave like CPython 3.8 here yet (7.3.7)
+    if (3, 8) <= sys.version_info < (3, 10) and env.CPYTHON:
+        with env.deprecated_call():
+            assert convert(Int()) == 42
+    else:
+        assert convert(Int()) == 42
+    requires_conversion(Int())
+    cant_convert(NotInt())
+    cant_convert(Float())
+
+    # Before Python 3.8, `PyLong_AsLong` does not pick up on `obj.__index__`,
+    # but pybind11 "backports" this behavior.
+    assert convert(Index()) == 42
+    assert noconvert(Index()) == 42
+    assert convert(IntAndIndex()) == 0  # Fishy; `int(DoubleThought)` == 42
+    assert noconvert(IntAndIndex()) == 0
+    assert convert(RaisingTypeErrorOnIndex()) == 42
+    requires_conversion(RaisingTypeErrorOnIndex())
+    assert convert(RaisingValueErrorOnIndex()) == 42
+    requires_conversion(RaisingValueErrorOnIndex())
+
+
+def test_numpy_int_convert():
+    np = pytest.importorskip("numpy")
+
+    convert, noconvert = m.int_passthrough, m.int_passthrough_noconvert
+
+    def require_implicit(v):
+        pytest.raises(TypeError, noconvert, v)
+
+    # `np.intc` is an alias that corresponds to a C++ `int`
+    assert convert(np.intc(42)) == 42
+    assert noconvert(np.intc(42)) == 42
+
+    # The implicit conversion from np.float32 is undesirable but currently accepted.
+    # TODO: Avoid DeprecationWarning in `PyLong_AsLong` (and similar)
+    # TODO: PyPy 3.8 does not behave like CPython 3.8 here yet (7.3.7)
+    # https://github.com/pybind/pybind11/issues/3408
+    if (3, 8) <= sys.version_info < (3, 10) and env.CPYTHON:
+        with env.deprecated_call():
+            assert convert(np.float32(3.14159)) == 3
+    else:
+        assert convert(np.float32(3.14159)) == 3
+    require_implicit(np.float32(3.14159))
+
+
+def test_tuple(doc):
+    """std::pair <-> tuple & std::tuple <-> tuple"""
+    assert m.pair_passthrough((True, "test")) == ("test", True)
+    assert m.tuple_passthrough((True, "test", 5)) == (5, "test", True)
+    # Any sequence can be cast to a std::pair or std::tuple
+    assert m.pair_passthrough([True, "test"]) == ("test", True)
+    assert m.tuple_passthrough([True, "test", 5]) == (5, "test", True)
+    assert m.empty_tuple() == ()
+
+    assert (
+        doc(m.pair_passthrough)
+        == """
+        pair_passthrough(arg0: tuple[bool, str]) -> tuple[str, bool]
+
+        Return a pair in reversed order
+    """
+    )
+    assert (
+        doc(m.tuple_passthrough)
+        == """
+        tuple_passthrough(arg0: tuple[bool, str, int]) -> tuple[int, str, bool]
+
+        Return a triple in reversed order
+    """
+    )
+
+    assert m.rvalue_pair() == ("rvalue", "rvalue")
+    assert m.lvalue_pair() == ("lvalue", "lvalue")
+    assert m.rvalue_tuple() == ("rvalue", "rvalue", "rvalue")
+    assert m.lvalue_tuple() == ("lvalue", "lvalue", "lvalue")
+    assert m.rvalue_nested() == ("rvalue", ("rvalue", ("rvalue", "rvalue")))
+    assert m.lvalue_nested() == ("lvalue", ("lvalue", ("lvalue", "lvalue")))
+
+    assert m.int_string_pair() == (2, "items")
+
+
+def test_builtins_cast_return_none():
+    """Casters produced with PYBIND11_TYPE_CASTER() should convert nullptr to None"""
+    assert m.return_none_string() is None
+    assert m.return_none_char() is None
+    assert m.return_none_bool() is None
+    assert m.return_none_int() is None
+    assert m.return_none_float() is None
+    assert m.return_none_pair() is None
+
+
+def test_none_deferred():
+    """None passed as various argument types should defer to other overloads"""
+    assert not m.defer_none_cstring("abc")
+    assert m.defer_none_cstring(None)
+    assert not m.defer_none_custom(UserType())
+    assert m.defer_none_custom(None)
+    assert m.nodefer_none_void(None)
+
+
+def test_void_caster():
+    assert m.load_nullptr_t(None) is None
+    assert m.cast_nullptr_t() is None
+
+
+def test_reference_wrapper():
+    """std::reference_wrapper for builtin and user types"""
+    assert m.refwrap_builtin(42) == 420
+    assert m.refwrap_usertype(UserType(42)) == 42
+    assert m.refwrap_usertype_const(UserType(42)) == 42
+
+    with pytest.raises(TypeError) as excinfo:
+        m.refwrap_builtin(None)
+    assert "incompatible function arguments" in str(excinfo.value)
+
+    with pytest.raises(TypeError) as excinfo:
+        m.refwrap_usertype(None)
+    assert "incompatible function arguments" in str(excinfo.value)
+
+    assert m.refwrap_lvalue().value == 1
+    assert m.refwrap_lvalue_const().value == 1
+
+    a1 = m.refwrap_list(copy=True)
+    a2 = m.refwrap_list(copy=True)
+    assert [x.value for x in a1] == [2, 3]
+    assert [x.value for x in a2] == [2, 3]
+    assert a1[0] is not a2[0]
+    assert a1[1] is not a2[1]
+
+    b1 = m.refwrap_list(copy=False)
+    b2 = m.refwrap_list(copy=False)
+    assert [x.value for x in b1] == [1, 2]
+    assert [x.value for x in b2] == [1, 2]
+    assert b1[0] is b2[0]
+    assert b1[1] is b2[1]
+
+    assert m.refwrap_iiw(IncType(5)) == 5
+    assert m.refwrap_call_iiw(IncType(10), m.refwrap_iiw) == [10, 10, 10, 10]
+
+
+def test_complex_cast():
+    """std::complex casts"""
+    assert m.complex_cast(1) == "1.0"
+    assert m.complex_cast(2j) == "(0.0, 2.0)"
+
+
+def test_bool_caster():
+    """Test bool caster implicit conversions."""
+    convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert
+
+    def require_implicit(v):
+        pytest.raises(TypeError, noconvert, v)
+
+    def cant_convert(v):
+        pytest.raises(TypeError, convert, v)
+
+    # straight up bool
+    assert convert(True) is True
+    assert convert(False) is False
+    assert noconvert(True) is True
+    assert noconvert(False) is False
+
+    # None requires implicit conversion
+    require_implicit(None)
+    assert convert(None) is False
+
+    class A:
+        def __init__(self, x):
+            self.x = x
+
+        def __nonzero__(self):
+            return self.x
+
+        def __bool__(self):
+            return self.x
+
+    class B:
+        pass
+
+    # Arbitrary objects are not accepted
+    cant_convert(object())
+    cant_convert(B())
+
+    # Objects with __nonzero__ / __bool__ defined can be converted
+    require_implicit(A(True))
+    assert convert(A(True)) is True
+    assert convert(A(False)) is False
+
+
+def test_numpy_bool():
+    np = pytest.importorskip("numpy")
+
+    convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert
+
+    def cant_convert(v):
+        pytest.raises(TypeError, convert, v)
+
+    # np.bool_ is not considered implicit
+    assert convert(np.bool_(True)) is True
+    assert convert(np.bool_(False)) is False
+    assert noconvert(np.bool_(True)) is True
+    assert noconvert(np.bool_(False)) is False
+    cant_convert(np.zeros(2, dtype="int"))
+
+
+def test_int_long():
+    assert isinstance(m.int_cast(), int)
+    assert isinstance(m.long_cast(), int)
+    assert isinstance(m.longlong_cast(), int)
+
+
+def test_void_caster_2():
+    assert m.test_void_caster()
+
+
+def test_const_ref_caster():
+    """Verifies that const-ref is propagated through type_caster cast_op.
+    The returned ConstRefCasted type is a minimal type that is constructed to
+    reference the casting mode used.
+    """
+    x = False
+    assert m.takes(x) == 1
+    assert m.takes_move(x) == 1
+
+    assert m.takes_ptr(x) == 3
+    assert m.takes_ref(x) == 2
+    assert m.takes_ref_wrap(x) == 2
+
+    assert m.takes_const_ptr(x) == 5
+    assert m.takes_const_ref(x) == 4
+    assert m.takes_const_ref_wrap(x) == 4

third_party/CityFlow/extern/pybind11/tests/test_call_policies.cpp

@@ -1,115 +1,115 @@
-/*
-    tests/test_call_policies.cpp -- keep_alive and call_guard
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-struct CustomGuard {
-    static bool enabled;
-
-    CustomGuard() { enabled = true; }
-    ~CustomGuard() { enabled = false; }
-
-    static const char *report_status() { return enabled ? "guarded" : "unguarded"; }
-};
-bool CustomGuard::enabled = false;
-
-struct DependentGuard {
-    static bool enabled;
-
-    DependentGuard() { enabled = CustomGuard::enabled; }
-    ~DependentGuard() { enabled = false; }
-
-    static const char *report_status() { return enabled ? "guarded" : "unguarded"; }
-};
-bool DependentGuard::enabled = false;
-
-TEST_SUBMODULE(call_policies, m) {
-    // Parent/Child are used in:
-    // test_keep_alive_argument, test_keep_alive_return_value, test_alive_gc_derived,
-    // test_alive_gc_multi_derived, test_return_none, test_keep_alive_constructor
-    class Child {
-    public:
-        Child() { py::print("Allocating child."); }
-        Child(const Child &) = default;
-        Child(Child &&) = default;
-        ~Child() { py::print("Releasing child."); }
-    };
-    py::class_<Child>(m, "Child").def(py::init<>());
-
-    class Parent {
-    public:
-        Parent() { py::print("Allocating parent."); }
-        Parent(const Parent &parent) = default;
-        ~Parent() { py::print("Releasing parent."); }
-        void addChild(Child *) {}
-        Child *returnChild() { return new Child(); }
-        Child *returnNullChild() { return nullptr; }
-        static Child *staticFunction(Parent *) { return new Child(); }
-    };
-    py::class_<Parent>(m, "Parent")
-        .def(py::init<>())
-        .def(py::init([](Child *) { return new Parent(); }), py::keep_alive<1, 2>())
-        .def("addChild", &Parent::addChild)
-        .def("addChildKeepAlive", &Parent::addChild, py::keep_alive<1, 2>())
-        .def("returnChild", &Parent::returnChild)
-        .def("returnChildKeepAlive", &Parent::returnChild, py::keep_alive<1, 0>())
-        .def("returnNullChildKeepAliveChild", &Parent::returnNullChild, py::keep_alive<1, 0>())
-        .def("returnNullChildKeepAliveParent", &Parent::returnNullChild, py::keep_alive<0, 1>())
-        .def_static("staticFunction", &Parent::staticFunction, py::keep_alive<1, 0>());
-
-    m.def(
-        "free_function", [](Parent *, Child *) {}, py::keep_alive<1, 2>());
-    m.def(
-        "invalid_arg_index", [] {}, py::keep_alive<0, 1>());
-
-#if !defined(PYPY_VERSION)
-    // test_alive_gc
-    class ParentGC : public Parent {
-    public:
-        using Parent::Parent;
-    };
-    py::class_<ParentGC, Parent>(m, "ParentGC", py::dynamic_attr()).def(py::init<>());
-#endif
-
-    // test_call_guard
-    m.def("unguarded_call", &CustomGuard::report_status);
-    m.def("guarded_call", &CustomGuard::report_status, py::call_guard<CustomGuard>());
-
-    m.def(
-        "multiple_guards_correct_order",
-        []() {
-            return CustomGuard::report_status() + std::string(" & ")
-                   + DependentGuard::report_status();
-        },
-        py::call_guard<CustomGuard, DependentGuard>());
-
-    m.def(
-        "multiple_guards_wrong_order",
-        []() {
-            return DependentGuard::report_status() + std::string(" & ")
-                   + CustomGuard::report_status();
-        },
-        py::call_guard<DependentGuard, CustomGuard>());
-
-#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
-    // `py::call_guard<py::gil_scoped_release>()` should work in PyPy as well,
-    // but it's unclear how to test it without `PyGILState_GetThisThreadState`.
-    auto report_gil_status = []() {
-        auto is_gil_held = false;
-        if (auto *tstate = py::detail::get_thread_state_unchecked()) {
-            is_gil_held = (tstate == PyGILState_GetThisThreadState());
-        }
-
-        return is_gil_held ? "GIL held" : "GIL released";
-    };
-
-    m.def("with_gil", report_gil_status);
-    m.def("without_gil", report_gil_status, py::call_guard<py::gil_scoped_release>());
-#endif
-}
+/*
+    tests/test_call_policies.cpp -- keep_alive and call_guard
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "pybind11_tests.h"
+
+struct CustomGuard {
+    static bool enabled;
+
+    CustomGuard() { enabled = true; }
+    ~CustomGuard() { enabled = false; }
+
+    static const char *report_status() { return enabled ? "guarded" : "unguarded"; }
+};
+bool CustomGuard::enabled = false;
+
+struct DependentGuard {
+    static bool enabled;
+
+    DependentGuard() { enabled = CustomGuard::enabled; }
+    ~DependentGuard() { enabled = false; }
+
+    static const char *report_status() { return enabled ? "guarded" : "unguarded"; }
+};
+bool DependentGuard::enabled = false;
+
+TEST_SUBMODULE(call_policies, m) {
+    // Parent/Child are used in:
+    // test_keep_alive_argument, test_keep_alive_return_value, test_alive_gc_derived,
+    // test_alive_gc_multi_derived, test_return_none, test_keep_alive_constructor
+    class Child {
+    public:
+        Child() { py::print("Allocating child."); }
+        Child(const Child &) = default;
+        Child(Child &&) = default;
+        ~Child() { py::print("Releasing child."); }
+    };
+    py::class_<Child>(m, "Child").def(py::init<>());
+
+    class Parent {
+    public:
+        Parent() { py::print("Allocating parent."); }
+        Parent(const Parent &parent) = default;
+        ~Parent() { py::print("Releasing parent."); }
+        void addChild(Child *) {}
+        Child *returnChild() { return new Child(); }
+        Child *returnNullChild() { return nullptr; }
+        static Child *staticFunction(Parent *) { return new Child(); }
+    };
+    py::class_<Parent>(m, "Parent")
+        .def(py::init<>())
+        .def(py::init([](Child *) { return new Parent(); }), py::keep_alive<1, 2>())
+        .def("addChild", &Parent::addChild)
+        .def("addChildKeepAlive", &Parent::addChild, py::keep_alive<1, 2>())
+        .def("returnChild", &Parent::returnChild)
+        .def("returnChildKeepAlive", &Parent::returnChild, py::keep_alive<1, 0>())
+        .def("returnNullChildKeepAliveChild", &Parent::returnNullChild, py::keep_alive<1, 0>())
+        .def("returnNullChildKeepAliveParent", &Parent::returnNullChild, py::keep_alive<0, 1>())
+        .def_static("staticFunction", &Parent::staticFunction, py::keep_alive<1, 0>());
+
+    m.def(
+        "free_function", [](Parent *, Child *) {}, py::keep_alive<1, 2>());
+    m.def(
+        "invalid_arg_index", [] {}, py::keep_alive<0, 1>());
+
+#if !defined(PYPY_VERSION)
+    // test_alive_gc
+    class ParentGC : public Parent {
+    public:
+        using Parent::Parent;
+    };
+    py::class_<ParentGC, Parent>(m, "ParentGC", py::dynamic_attr()).def(py::init<>());
+#endif
+
+    // test_call_guard
+    m.def("unguarded_call", &CustomGuard::report_status);
+    m.def("guarded_call", &CustomGuard::report_status, py::call_guard<CustomGuard>());
+
+    m.def(
+        "multiple_guards_correct_order",
+        []() {
+            return CustomGuard::report_status() + std::string(" & ")
+                   + DependentGuard::report_status();
+        },
+        py::call_guard<CustomGuard, DependentGuard>());
+
+    m.def(
+        "multiple_guards_wrong_order",
+        []() {
+            return DependentGuard::report_status() + std::string(" & ")
+                   + CustomGuard::report_status();
+        },
+        py::call_guard<DependentGuard, CustomGuard>());
+
+#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
+    // `py::call_guard<py::gil_scoped_release>()` should work in PyPy as well,
+    // but it's unclear how to test it without `PyGILState_GetThisThreadState`.
+    auto report_gil_status = []() {
+        auto is_gil_held = false;
+        if (auto *tstate = py::detail::get_thread_state_unchecked()) {
+            is_gil_held = (tstate == PyGILState_GetThisThreadState());
+        }
+
+        return is_gil_held ? "GIL held" : "GIL released";
+    };
+
+    m.def("with_gil", report_gil_status);
+    m.def("without_gil", report_gil_status, py::call_guard<py::gil_scoped_release>());
+#endif
+}

third_party/CityFlow/extern/pybind11/tests/test_call_policies.py

@@ -1,247 +1,247 @@
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import ConstructorStats
-from pybind11_tests import call_policies as m
-
-
-@pytest.mark.xfail("env.PYPY", reason="sometimes comes out 1 off on PyPy", strict=False)
-def test_keep_alive_argument(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.addChild(m.Child())
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert (
-        capture
-        == """
-        Allocating child.
-        Releasing child.
-    """
-    )
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.addChildKeepAlive(m.Child())
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert capture == "Allocating child."
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-    p = m.Parent()
-    c = m.Child()
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    m.free_function(p, c)
-    del c
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    del p
-    assert ConstructorStats.detail_reg_inst() == n_inst
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.invalid_arg_index()
-    assert str(excinfo.value) == "Could not activate keep_alive!"
-
-
-def test_keep_alive_return_value(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnChild()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert (
-        capture
-        == """
-        Allocating child.
-        Releasing child.
-    """
-    )
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnChildKeepAlive()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert capture == "Allocating child."
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-    p = m.Parent()
-    assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    with capture:
-        m.Parent.staticFunction(p)
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert capture == "Allocating child."
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2447
-@pytest.mark.xfail("env.PYPY", reason="_PyObject_GetDictPtr is unimplemented")
-def test_alive_gc(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    p = m.ParentGC()
-    p.addChildKeepAlive(m.Child())
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    lst = [p]
-    lst.append(lst)  # creates a circular reference
-    with capture:
-        del p, lst
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-def test_alive_gc_derived(capture):
-    class Derived(m.Parent):
-        pass
-
-    n_inst = ConstructorStats.detail_reg_inst()
-    p = Derived()
-    p.addChildKeepAlive(m.Child())
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    lst = [p]
-    lst.append(lst)  # creates a circular reference
-    with capture:
-        del p, lst
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-def test_alive_gc_multi_derived(capture):
-    class Derived(m.Parent, m.Child):
-        def __init__(self):
-            m.Parent.__init__(self)
-            m.Child.__init__(self)
-
-    n_inst = ConstructorStats.detail_reg_inst()
-    p = Derived()
-    p.addChildKeepAlive(m.Child())
-    # +3 rather than +2 because Derived corresponds to two registered instances
-    assert ConstructorStats.detail_reg_inst() == n_inst + 3
-    lst = [p]
-    lst.append(lst)  # creates a circular reference
-    with capture:
-        del p, lst
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-        Releasing child.
-    """
-    )
-
-
-def test_return_none(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnNullChildKeepAliveChild()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert capture == ""
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnNullChildKeepAliveParent()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert capture == ""
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-
-def test_keep_alive_constructor(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-
-    with capture:
-        p = m.Parent(m.Child())
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert (
-        capture
-        == """
-        Allocating child.
-        Allocating parent.
-    """
-    )
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-def test_call_guard():
-    assert m.unguarded_call() == "unguarded"
-    assert m.guarded_call() == "guarded"
-
-    assert m.multiple_guards_correct_order() == "guarded & guarded"
-    assert m.multiple_guards_wrong_order() == "unguarded & guarded"
-
-    if hasattr(m, "with_gil"):
-        assert m.with_gil() == "GIL held"
-        assert m.without_gil() == "GIL released"
+import pytest
+
+import env  # noqa: F401
+from pybind11_tests import ConstructorStats
+from pybind11_tests import call_policies as m
+
+
+@pytest.mark.xfail("env.PYPY", reason="sometimes comes out 1 off on PyPy", strict=False)
+def test_keep_alive_argument(capture):
+    n_inst = ConstructorStats.detail_reg_inst()
+    with capture:
+        p = m.Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.addChild(m.Child())
+        assert ConstructorStats.detail_reg_inst() == n_inst + 1
+    assert (
+        capture
+        == """
+        Allocating child.
+        Releasing child.
+    """
+    )
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert capture == "Releasing parent."
+
+    with capture:
+        p = m.Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.addChildKeepAlive(m.Child())
+        assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    assert capture == "Allocating child."
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert (
+        capture
+        == """
+        Releasing parent.
+        Releasing child.
+    """
+    )
+
+    p = m.Parent()
+    c = m.Child()
+    assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    m.free_function(p, c)
+    del c
+    assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    del p
+    assert ConstructorStats.detail_reg_inst() == n_inst
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m.invalid_arg_index()
+    assert str(excinfo.value) == "Could not activate keep_alive!"
+
+
+def test_keep_alive_return_value(capture):
+    n_inst = ConstructorStats.detail_reg_inst()
+    with capture:
+        p = m.Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnChild()
+        assert ConstructorStats.detail_reg_inst() == n_inst + 1
+    assert (
+        capture
+        == """
+        Allocating child.
+        Releasing child.
+    """
+    )
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert capture == "Releasing parent."
+
+    with capture:
+        p = m.Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnChildKeepAlive()
+        assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    assert capture == "Allocating child."
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert (
+        capture
+        == """
+        Releasing parent.
+        Releasing child.
+    """
+    )
+
+    p = m.Parent()
+    assert ConstructorStats.detail_reg_inst() == n_inst + 1
+    with capture:
+        m.Parent.staticFunction(p)
+        assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    assert capture == "Allocating child."
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert (
+        capture
+        == """
+        Releasing parent.
+        Releasing child.
+    """
+    )
+
+
+# https://foss.heptapod.net/pypy/pypy/-/issues/2447
+@pytest.mark.xfail("env.PYPY", reason="_PyObject_GetDictPtr is unimplemented")
+def test_alive_gc(capture):
+    n_inst = ConstructorStats.detail_reg_inst()
+    p = m.ParentGC()
+    p.addChildKeepAlive(m.Child())
+    assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    lst = [p]
+    lst.append(lst)  # creates a circular reference
+    with capture:
+        del p, lst
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert (
+        capture
+        == """
+        Releasing parent.
+        Releasing child.
+    """
+    )
+
+
+def test_alive_gc_derived(capture):
+    class Derived(m.Parent):
+        pass
+
+    n_inst = ConstructorStats.detail_reg_inst()
+    p = Derived()
+    p.addChildKeepAlive(m.Child())
+    assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    lst = [p]
+    lst.append(lst)  # creates a circular reference
+    with capture:
+        del p, lst
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert (
+        capture
+        == """
+        Releasing parent.
+        Releasing child.
+    """
+    )
+
+
+def test_alive_gc_multi_derived(capture):
+    class Derived(m.Parent, m.Child):
+        def __init__(self):
+            m.Parent.__init__(self)
+            m.Child.__init__(self)
+
+    n_inst = ConstructorStats.detail_reg_inst()
+    p = Derived()
+    p.addChildKeepAlive(m.Child())
+    # +3 rather than +2 because Derived corresponds to two registered instances
+    assert ConstructorStats.detail_reg_inst() == n_inst + 3
+    lst = [p]
+    lst.append(lst)  # creates a circular reference
+    with capture:
+        del p, lst
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert (
+        capture
+        == """
+        Releasing parent.
+        Releasing child.
+        Releasing child.
+    """
+    )
+
+
+def test_return_none(capture):
+    n_inst = ConstructorStats.detail_reg_inst()
+    with capture:
+        p = m.Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnNullChildKeepAliveChild()
+        assert ConstructorStats.detail_reg_inst() == n_inst + 1
+    assert capture == ""
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert capture == "Releasing parent."
+
+    with capture:
+        p = m.Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnNullChildKeepAliveParent()
+        assert ConstructorStats.detail_reg_inst() == n_inst + 1
+    assert capture == ""
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert capture == "Releasing parent."
+
+
+def test_keep_alive_constructor(capture):
+    n_inst = ConstructorStats.detail_reg_inst()
+
+    with capture:
+        p = m.Parent(m.Child())
+        assert ConstructorStats.detail_reg_inst() == n_inst + 2
+    assert (
+        capture
+        == """
+        Allocating child.
+        Allocating parent.
+    """
+    )
+    with capture:
+        del p
+        assert ConstructorStats.detail_reg_inst() == n_inst
+    assert (
+        capture
+        == """
+        Releasing parent.
+        Releasing child.
+    """
+    )
+
+
+def test_call_guard():
+    assert m.unguarded_call() == "unguarded"
+    assert m.guarded_call() == "guarded"
+
+    assert m.multiple_guards_correct_order() == "guarded & guarded"
+    assert m.multiple_guards_wrong_order() == "unguarded & guarded"
+
+    if hasattr(m, "with_gil"):
+        assert m.with_gil() == "GIL held"
+        assert m.without_gil() == "GIL released"

third_party/CityFlow/extern/pybind11/tests/test_callbacks.cpp

@@ -1,280 +1,280 @@
-/*
-    tests/test_callbacks.cpp -- callbacks
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/functional.h>
-
-#include "constructor_stats.h"
-#include "pybind11_tests.h"
-
-#include <thread>
-
-int dummy_function(int i) { return i + 1; }
-
-TEST_SUBMODULE(callbacks, m) {
-    // test_callbacks, test_function_signatures
-    m.def("test_callback1", [](const py::object &func) { return func(); });
-    m.def("test_callback2", [](const py::object &func) { return func("Hello", 'x', true, 5); });
-    m.def("test_callback3", [](const std::function<int(int)> &func) {
-        return "func(43) = " + std::to_string(func(43));
-    });
-    m.def("test_callback4",
-          []() -> std::function<int(int)> { return [](int i) { return i + 1; }; });
-    m.def("test_callback5",
-          []() { return py::cpp_function([](int i) { return i + 1; }, py::arg("number")); });
-
-    // test_keyword_args_and_generalized_unpacking
-    m.def("test_tuple_unpacking", [](const py::function &f) {
-        auto t1 = py::make_tuple(2, 3);
-        auto t2 = py::make_tuple(5, 6);
-        return f("positional", 1, *t1, 4, *t2);
-    });
-
-    m.def("test_dict_unpacking", [](const py::function &f) {
-        auto d1 = py::dict("key"_a = "value", "a"_a = 1);
-        auto d2 = py::dict();
-        auto d3 = py::dict("b"_a = 2);
-        return f("positional", 1, **d1, **d2, **d3);
-    });
-
-    m.def("test_keyword_args", [](const py::function &f) { return f("x"_a = 10, "y"_a = 20); });
-
-    m.def("test_unpacking_and_keywords1", [](const py::function &f) {
-        auto args = py::make_tuple(2);
-        auto kwargs = py::dict("d"_a = 4);
-        return f(1, *args, "c"_a = 3, **kwargs);
-    });
-
-    m.def("test_unpacking_and_keywords2", [](const py::function &f) {
-        auto kwargs1 = py::dict("a"_a = 1);
-        auto kwargs2 = py::dict("c"_a = 3, "d"_a = 4);
-        return f("positional",
-                 *py::make_tuple(1),
-                 2,
-                 *py::make_tuple(3, 4),
-                 5,
-                 "key"_a = "value",
-                 **kwargs1,
-                 "b"_a = 2,
-                 **kwargs2,
-                 "e"_a = 5);
-    });
-
-    m.def("test_unpacking_error1", [](const py::function &f) {
-        auto kwargs = py::dict("x"_a = 3);
-        return f("x"_a = 1, "y"_a = 2, **kwargs); // duplicate ** after keyword
-    });
-
-    m.def("test_unpacking_error2", [](const py::function &f) {
-        auto kwargs = py::dict("x"_a = 3);
-        return f(**kwargs, "x"_a = 1); // duplicate keyword after **
-    });
-
-    m.def("test_arg_conversion_error1",
-          [](const py::function &f) { f(234, UnregisteredType(), "kw"_a = 567); });
-
-    m.def("test_arg_conversion_error2", [](const py::function &f) {
-        f(234, "expected_name"_a = UnregisteredType(), "kw"_a = 567);
-    });
-
-    // test_lambda_closure_cleanup
-    struct Payload {
-        Payload() { print_default_created(this); }
-        ~Payload() { print_destroyed(this); }
-        Payload(const Payload &) { print_copy_created(this); }
-        Payload(Payload &&) noexcept { print_move_created(this); }
-    };
-    // Export the payload constructor statistics for testing purposes:
-    m.def("payload_cstats", &ConstructorStats::get<Payload>);
-    m.def("test_lambda_closure_cleanup", []() -> std::function<void()> {
-        Payload p;
-
-        // In this situation, `Func` in the implementation of
-        // `cpp_function::initialize` is NOT trivially destructible.
-        return [p]() {
-            /* p should be cleaned up when the returned function is garbage collected */
-            (void) p;
-        };
-    });
-
-    class CppCallable {
-    public:
-        CppCallable() { track_default_created(this); }
-        ~CppCallable() { track_destroyed(this); }
-        CppCallable(const CppCallable &) { track_copy_created(this); }
-        CppCallable(CppCallable &&) noexcept { track_move_created(this); }
-        void operator()() {}
-    };
-
-    m.def("test_cpp_callable_cleanup", []() {
-        // Related issue: https://github.com/pybind/pybind11/issues/3228
-        // Related PR: https://github.com/pybind/pybind11/pull/3229
-        py::list alive_counts;
-        ConstructorStats &stat = ConstructorStats::get<CppCallable>();
-        alive_counts.append(stat.alive());
-        {
-            CppCallable cpp_callable;
-            alive_counts.append(stat.alive());
-            {
-                // In this situation, `Func` in the implementation of
-                // `cpp_function::initialize` IS trivially destructible,
-                // only `capture` is not.
-                py::cpp_function py_func(cpp_callable);
-                py::detail::silence_unused_warnings(py_func);
-                alive_counts.append(stat.alive());
-            }
-            alive_counts.append(stat.alive());
-            {
-                py::cpp_function py_func(std::move(cpp_callable));
-                py::detail::silence_unused_warnings(py_func);
-                alive_counts.append(stat.alive());
-            }
-            alive_counts.append(stat.alive());
-        }
-        alive_counts.append(stat.alive());
-        return alive_counts;
-    });
-
-    // test_cpp_function_roundtrip
-    /* Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer */
-    m.def("dummy_function", &dummy_function);
-    m.def("dummy_function_overloaded", [](int i, int j) { return i + j; });
-    m.def("dummy_function_overloaded", &dummy_function);
-    m.def("dummy_function2", [](int i, int j) { return i + j; });
-    m.def(
-        "roundtrip",
-        [](std::function<int(int)> f, bool expect_none = false) {
-            if (expect_none && f) {
-                throw std::runtime_error("Expected None to be converted to empty std::function");
-            }
-            return f;
-        },
-        py::arg("f"),
-        py::arg("expect_none") = false);
-    m.def("test_dummy_function", [](const std::function<int(int)> &f) -> std::string {
-        using fn_type = int (*)(int);
-        const auto *result = f.target<fn_type>();
-        if (!result) {
-            auto r = f(1);
-            return "can't convert to function pointer: eval(1) = " + std::to_string(r);
-        }
-        if (*result == dummy_function) {
-            auto r = (*result)(1);
-            return "matches dummy_function: eval(1) = " + std::to_string(r);
-        }
-        return "argument does NOT match dummy_function. This should never happen!";
-    });
-
-    class AbstractBase {
-    public:
-        // [workaround(intel)] = default does not work here
-        // Defaulting this destructor results in linking errors with the Intel compiler
-        // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827)
-        virtual ~AbstractBase() {} // NOLINT(modernize-use-equals-default)
-        virtual unsigned int func() = 0;
-    };
-    m.def("func_accepting_func_accepting_base",
-          [](const std::function<double(AbstractBase &)> &) {});
-
-    struct MovableObject {
-        bool valid = true;
-
-        MovableObject() = default;
-        MovableObject(const MovableObject &) = default;
-        MovableObject &operator=(const MovableObject &) = default;
-        MovableObject(MovableObject &&o) noexcept : valid(o.valid) { o.valid = false; }
-        MovableObject &operator=(MovableObject &&o) noexcept {
-            valid = o.valid;
-            o.valid = false;
-            return *this;
-        }
-    };
-    py::class_<MovableObject>(m, "MovableObject");
-
-    // test_movable_object
-    m.def("callback_with_movable", [](const std::function<void(MovableObject &)> &f) {
-        auto x = MovableObject();
-        f(x);           // lvalue reference shouldn't move out object
-        return x.valid; // must still return `true`
-    });
-
-    // test_bound_method_callback
-    struct CppBoundMethodTest {};
-    py::class_<CppBoundMethodTest>(m, "CppBoundMethodTest")
-        .def(py::init<>())
-        .def("triple", [](CppBoundMethodTest &, int val) { return 3 * val; });
-
-    // This checks that builtin functions can be passed as callbacks
-    // rather than throwing RuntimeError due to trying to extract as capsule
-    m.def("test_sum_builtin",
-          [](const std::function<double(py::iterable)> &sum_builtin, const py::iterable &i) {
-              return sum_builtin(i);
-          });
-
-    // test async Python callbacks
-    using callback_f = std::function<void(int)>;
-    m.def("test_async_callback", [](const callback_f &f, const py::list &work) {
-        // make detached thread that calls `f` with piece of work after a little delay
-        auto start_f = [f](int j) {
-            auto invoke_f = [f, j] {
-                std::this_thread::sleep_for(std::chrono::milliseconds(50));
-                f(j);
-            };
-            auto t = std::thread(std::move(invoke_f));
-            t.detach();
-        };
-
-        // spawn worker threads
-        for (auto i : work) {
-            start_f(py::cast<int>(i));
-        }
-    });
-
-    m.def("callback_num_times", [](const py::function &f, std::size_t num) {
-        for (std::size_t i = 0; i < num; i++) {
-            f();
-        }
-    });
-
-    auto *custom_def = []() {
-        static PyMethodDef def;
-        def.ml_name = "example_name";
-        def.ml_doc = "Example doc";
-        def.ml_meth = [](PyObject *, PyObject *args) -> PyObject * {
-            if (PyTuple_Size(args) != 1) {
-                throw std::runtime_error("Invalid number of arguments for example_name");
-            }
-            PyObject *first = PyTuple_GetItem(args, 0);
-            if (!PyLong_Check(first)) {
-                throw std::runtime_error("Invalid argument to example_name");
-            }
-            auto result = py::cast(PyLong_AsLong(first) * 9);
-            return result.release().ptr();
-        };
-        def.ml_flags = METH_VARARGS;
-        return &def;
-    }();
-
-    // rec_capsule with name that has the same value (but not pointer) as our internal one
-    // This capsule should be detected by our code as foreign and not inspected as the pointers
-    // shouldn't match
-    constexpr const char *rec_capsule_name
-        = pybind11::detail::internals_function_record_capsule_name;
-    py::capsule rec_capsule(std::malloc(1), [](void *data) { std::free(data); });
-    rec_capsule.set_name(rec_capsule_name);
-    m.add_object("custom_function", PyCFunction_New(custom_def, rec_capsule.ptr()));
-
-    // This test requires a new ABI version to pass
-#if PYBIND11_INTERNALS_VERSION > 4
-    // rec_capsule with nullptr name
-    py::capsule rec_capsule2(std::malloc(1), [](void *data) { std::free(data); });
-    m.add_object("custom_function2", PyCFunction_New(custom_def, rec_capsule2.ptr()));
-#else
-    m.add_object("custom_function2", py::none());
-#endif
-}
+/*
+    tests/test_callbacks.cpp -- callbacks
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/functional.h>
+
+#include "constructor_stats.h"
+#include "pybind11_tests.h"
+
+#include <thread>
+
+int dummy_function(int i) { return i + 1; }
+
+TEST_SUBMODULE(callbacks, m) {
+    // test_callbacks, test_function_signatures
+    m.def("test_callback1", [](const py::object &func) { return func(); });
+    m.def("test_callback2", [](const py::object &func) { return func("Hello", 'x', true, 5); });
+    m.def("test_callback3", [](const std::function<int(int)> &func) {
+        return "func(43) = " + std::to_string(func(43));
+    });
+    m.def("test_callback4",
+          []() -> std::function<int(int)> { return [](int i) { return i + 1; }; });
+    m.def("test_callback5",
+          []() { return py::cpp_function([](int i) { return i + 1; }, py::arg("number")); });
+
+    // test_keyword_args_and_generalized_unpacking
+    m.def("test_tuple_unpacking", [](const py::function &f) {
+        auto t1 = py::make_tuple(2, 3);
+        auto t2 = py::make_tuple(5, 6);
+        return f("positional", 1, *t1, 4, *t2);
+    });
+
+    m.def("test_dict_unpacking", [](const py::function &f) {
+        auto d1 = py::dict("key"_a = "value", "a"_a = 1);
+        auto d2 = py::dict();
+        auto d3 = py::dict("b"_a = 2);
+        return f("positional", 1, **d1, **d2, **d3);
+    });
+
+    m.def("test_keyword_args", [](const py::function &f) { return f("x"_a = 10, "y"_a = 20); });
+
+    m.def("test_unpacking_and_keywords1", [](const py::function &f) {
+        auto args = py::make_tuple(2);
+        auto kwargs = py::dict("d"_a = 4);
+        return f(1, *args, "c"_a = 3, **kwargs);
+    });
+
+    m.def("test_unpacking_and_keywords2", [](const py::function &f) {
+        auto kwargs1 = py::dict("a"_a = 1);
+        auto kwargs2 = py::dict("c"_a = 3, "d"_a = 4);
+        return f("positional",
+                 *py::make_tuple(1),
+                 2,
+                 *py::make_tuple(3, 4),
+                 5,
+                 "key"_a = "value",
+                 **kwargs1,
+                 "b"_a = 2,
+                 **kwargs2,
+                 "e"_a = 5);
+    });
+
+    m.def("test_unpacking_error1", [](const py::function &f) {
+        auto kwargs = py::dict("x"_a = 3);
+        return f("x"_a = 1, "y"_a = 2, **kwargs); // duplicate ** after keyword
+    });
+
+    m.def("test_unpacking_error2", [](const py::function &f) {
+        auto kwargs = py::dict("x"_a = 3);
+        return f(**kwargs, "x"_a = 1); // duplicate keyword after **
+    });
+
+    m.def("test_arg_conversion_error1",
+          [](const py::function &f) { f(234, UnregisteredType(), "kw"_a = 567); });
+
+    m.def("test_arg_conversion_error2", [](const py::function &f) {
+        f(234, "expected_name"_a = UnregisteredType(), "kw"_a = 567);
+    });
+
+    // test_lambda_closure_cleanup
+    struct Payload {
+        Payload() { print_default_created(this); }
+        ~Payload() { print_destroyed(this); }
+        Payload(const Payload &) { print_copy_created(this); }
+        Payload(Payload &&) noexcept { print_move_created(this); }
+    };
+    // Export the payload constructor statistics for testing purposes:
+    m.def("payload_cstats", &ConstructorStats::get<Payload>);
+    m.def("test_lambda_closure_cleanup", []() -> std::function<void()> {
+        Payload p;
+
+        // In this situation, `Func` in the implementation of
+        // `cpp_function::initialize` is NOT trivially destructible.
+        return [p]() {
+            /* p should be cleaned up when the returned function is garbage collected */
+            (void) p;
+        };
+    });
+
+    class CppCallable {
+    public:
+        CppCallable() { track_default_created(this); }
+        ~CppCallable() { track_destroyed(this); }
+        CppCallable(const CppCallable &) { track_copy_created(this); }
+        CppCallable(CppCallable &&) noexcept { track_move_created(this); }
+        void operator()() {}
+    };
+
+    m.def("test_cpp_callable_cleanup", []() {
+        // Related issue: https://github.com/pybind/pybind11/issues/3228
+        // Related PR: https://github.com/pybind/pybind11/pull/3229
+        py::list alive_counts;
+        ConstructorStats &stat = ConstructorStats::get<CppCallable>();
+        alive_counts.append(stat.alive());
+        {
+            CppCallable cpp_callable;
+            alive_counts.append(stat.alive());
+            {
+                // In this situation, `Func` in the implementation of
+                // `cpp_function::initialize` IS trivially destructible,
+                // only `capture` is not.
+                py::cpp_function py_func(cpp_callable);
+                py::detail::silence_unused_warnings(py_func);
+                alive_counts.append(stat.alive());
+            }
+            alive_counts.append(stat.alive());
+            {
+                py::cpp_function py_func(std::move(cpp_callable));
+                py::detail::silence_unused_warnings(py_func);
+                alive_counts.append(stat.alive());
+            }
+            alive_counts.append(stat.alive());
+        }
+        alive_counts.append(stat.alive());
+        return alive_counts;
+    });
+
+    // test_cpp_function_roundtrip
+    /* Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer */
+    m.def("dummy_function", &dummy_function);
+    m.def("dummy_function_overloaded", [](int i, int j) { return i + j; });
+    m.def("dummy_function_overloaded", &dummy_function);
+    m.def("dummy_function2", [](int i, int j) { return i + j; });
+    m.def(
+        "roundtrip",
+        [](std::function<int(int)> f, bool expect_none = false) {
+            if (expect_none && f) {
+                throw std::runtime_error("Expected None to be converted to empty std::function");
+            }
+            return f;
+        },
+        py::arg("f"),
+        py::arg("expect_none") = false);
+    m.def("test_dummy_function", [](const std::function<int(int)> &f) -> std::string {
+        using fn_type = int (*)(int);
+        const auto *result = f.target<fn_type>();
+        if (!result) {
+            auto r = f(1);
+            return "can't convert to function pointer: eval(1) = " + std::to_string(r);
+        }
+        if (*result == dummy_function) {
+            auto r = (*result)(1);
+            return "matches dummy_function: eval(1) = " + std::to_string(r);
+        }
+        return "argument does NOT match dummy_function. This should never happen!";
+    });
+
+    class AbstractBase {
+    public:
+        // [workaround(intel)] = default does not work here
+        // Defaulting this destructor results in linking errors with the Intel compiler
+        // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827)
+        virtual ~AbstractBase() {} // NOLINT(modernize-use-equals-default)
+        virtual unsigned int func() = 0;
+    };
+    m.def("func_accepting_func_accepting_base",
+          [](const std::function<double(AbstractBase &)> &) {});
+
+    struct MovableObject {
+        bool valid = true;
+
+        MovableObject() = default;
+        MovableObject(const MovableObject &) = default;
+        MovableObject &operator=(const MovableObject &) = default;
+        MovableObject(MovableObject &&o) noexcept : valid(o.valid) { o.valid = false; }
+        MovableObject &operator=(MovableObject &&o) noexcept {
+            valid = o.valid;
+            o.valid = false;
+            return *this;
+        }
+    };
+    py::class_<MovableObject>(m, "MovableObject");
+
+    // test_movable_object
+    m.def("callback_with_movable", [](const std::function<void(MovableObject &)> &f) {
+        auto x = MovableObject();
+        f(x);           // lvalue reference shouldn't move out object
+        return x.valid; // must still return `true`
+    });
+
+    // test_bound_method_callback
+    struct CppBoundMethodTest {};
+    py::class_<CppBoundMethodTest>(m, "CppBoundMethodTest")
+        .def(py::init<>())
+        .def("triple", [](CppBoundMethodTest &, int val) { return 3 * val; });
+
+    // This checks that builtin functions can be passed as callbacks
+    // rather than throwing RuntimeError due to trying to extract as capsule
+    m.def("test_sum_builtin",
+          [](const std::function<double(py::iterable)> &sum_builtin, const py::iterable &i) {
+              return sum_builtin(i);
+          });
+
+    // test async Python callbacks
+    using callback_f = std::function<void(int)>;
+    m.def("test_async_callback", [](const callback_f &f, const py::list &work) {
+        // make detached thread that calls `f` with piece of work after a little delay
+        auto start_f = [f](int j) {
+            auto invoke_f = [f, j] {
+                std::this_thread::sleep_for(std::chrono::milliseconds(50));
+                f(j);
+            };
+            auto t = std::thread(std::move(invoke_f));
+            t.detach();
+        };
+
+        // spawn worker threads
+        for (auto i : work) {
+            start_f(py::cast<int>(i));
+        }
+    });
+
+    m.def("callback_num_times", [](const py::function &f, std::size_t num) {
+        for (std::size_t i = 0; i < num; i++) {
+            f();
+        }
+    });
+
+    auto *custom_def = []() {
+        static PyMethodDef def;
+        def.ml_name = "example_name";
+        def.ml_doc = "Example doc";
+        def.ml_meth = [](PyObject *, PyObject *args) -> PyObject * {
+            if (PyTuple_Size(args) != 1) {
+                throw std::runtime_error("Invalid number of arguments for example_name");
+            }
+            PyObject *first = PyTuple_GetItem(args, 0);
+            if (!PyLong_Check(first)) {
+                throw std::runtime_error("Invalid argument to example_name");
+            }
+            auto result = py::cast(PyLong_AsLong(first) * 9);
+            return result.release().ptr();
+        };
+        def.ml_flags = METH_VARARGS;
+        return &def;
+    }();
+
+    // rec_capsule with name that has the same value (but not pointer) as our internal one
+    // This capsule should be detected by our code as foreign and not inspected as the pointers
+    // shouldn't match
+    constexpr const char *rec_capsule_name
+        = pybind11::detail::internals_function_record_capsule_name;
+    py::capsule rec_capsule(std::malloc(1), [](void *data) { std::free(data); });
+    rec_capsule.set_name(rec_capsule_name);
+    m.add_object("custom_function", PyCFunction_New(custom_def, rec_capsule.ptr()));
+
+    // This test requires a new ABI version to pass
+#if PYBIND11_INTERNALS_VERSION > 4
+    // rec_capsule with nullptr name
+    py::capsule rec_capsule2(std::malloc(1), [](void *data) { std::free(data); });
+    m.add_object("custom_function2", PyCFunction_New(custom_def, rec_capsule2.ptr()));
+#else
+    m.add_object("custom_function2", py::none());
+#endif
+}

third_party/CityFlow/extern/pybind11/tests/test_callbacks.py

@@ -1,225 +1,225 @@
-import time
-from threading import Thread
-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import callbacks as m
-from pybind11_tests import detailed_error_messages_enabled
-
-
-def test_callbacks():
-    from functools import partial
-
-    def func1():
-        return "func1"
-
-    def func2(a, b, c, d):
-        return "func2", a, b, c, d
-
-    def func3(a):
-        return f"func3({a})"
-
-    assert m.test_callback1(func1) == "func1"
-    assert m.test_callback2(func2) == ("func2", "Hello", "x", True, 5)
-    assert m.test_callback1(partial(func2, 1, 2, 3, 4)) == ("func2", 1, 2, 3, 4)
-    assert m.test_callback1(partial(func3, "partial")) == "func3(partial)"
-    assert m.test_callback3(lambda i: i + 1) == "func(43) = 44"
-
-    f = m.test_callback4()
-    assert f(43) == 44
-    f = m.test_callback5()
-    assert f(number=43) == 44
-
-
-def test_bound_method_callback():
-    # Bound Python method:
-    class MyClass:
-        def double(self, val):
-            return 2 * val
-
-    z = MyClass()
-    assert m.test_callback3(z.double) == "func(43) = 86"
-
-    z = m.CppBoundMethodTest()
-    assert m.test_callback3(z.triple) == "func(43) = 129"
-
-
-def test_keyword_args_and_generalized_unpacking():
-    def f(*args, **kwargs):
-        return args, kwargs
-
-    assert m.test_tuple_unpacking(f) == (("positional", 1, 2, 3, 4, 5, 6), {})
-    assert m.test_dict_unpacking(f) == (
-        ("positional", 1),
-        {"key": "value", "a": 1, "b": 2},
-    )
-    assert m.test_keyword_args(f) == ((), {"x": 10, "y": 20})
-    assert m.test_unpacking_and_keywords1(f) == ((1, 2), {"c": 3, "d": 4})
-    assert m.test_unpacking_and_keywords2(f) == (
-        ("positional", 1, 2, 3, 4, 5),
-        {"key": "value", "a": 1, "b": 2, "c": 3, "d": 4, "e": 5},
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_unpacking_error1(f)
-    assert "Got multiple values for keyword argument" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_unpacking_error2(f)
-    assert "Got multiple values for keyword argument" in str(excinfo.value)
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.test_arg_conversion_error1(f)
-    assert str(excinfo.value) == "Unable to convert call argument " + (
-        "'1' of type 'UnregisteredType' to Python object"
-        if detailed_error_messages_enabled
-        else "'1' to Python object (#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)"
-    )
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.test_arg_conversion_error2(f)
-    assert str(excinfo.value) == "Unable to convert call argument " + (
-        "'expected_name' of type 'UnregisteredType' to Python object"
-        if detailed_error_messages_enabled
-        else "'expected_name' to Python object "
-        "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)"
-    )
-
-
-def test_lambda_closure_cleanup():
-    m.test_lambda_closure_cleanup()
-    cstats = m.payload_cstats()
-    assert cstats.alive() == 0
-    assert cstats.copy_constructions == 1
-    assert cstats.move_constructions >= 1
-
-
-def test_cpp_callable_cleanup():
-    alive_counts = m.test_cpp_callable_cleanup()
-    assert alive_counts == [0, 1, 2, 1, 2, 1, 0]
-
-
-def test_cpp_function_roundtrip():
-    """Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer"""
-
-    assert (
-        m.test_dummy_function(m.dummy_function) == "matches dummy_function: eval(1) = 2"
-    )
-    assert (
-        m.test_dummy_function(m.roundtrip(m.dummy_function))
-        == "matches dummy_function: eval(1) = 2"
-    )
-    assert (
-        m.test_dummy_function(m.dummy_function_overloaded)
-        == "matches dummy_function: eval(1) = 2"
-    )
-    assert m.roundtrip(None, expect_none=True) is None
-    assert (
-        m.test_dummy_function(lambda x: x + 2)
-        == "can't convert to function pointer: eval(1) = 3"
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_dummy_function(m.dummy_function2)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_dummy_function(lambda x, y: x + y)
-    assert any(
-        s in str(excinfo.value)
-        for s in ("missing 1 required positional argument", "takes exactly 2 arguments")
-    )
-
-
-def test_function_signatures(doc):
-    assert doc(m.test_callback3) == "test_callback3(arg0: Callable[[int], int]) -> str"
-    assert doc(m.test_callback4) == "test_callback4() -> Callable[[int], int]"
-
-
-def test_movable_object():
-    assert m.callback_with_movable(lambda _: None) is True
-
-
-@pytest.mark.skipif(
-    "env.PYPY",
-    reason="PyPy segfaults on here. See discussion on #1413.",
-)
-def test_python_builtins():
-    """Test if python builtins like sum() can be used as callbacks"""
-    assert m.test_sum_builtin(sum, [1, 2, 3]) == 6
-    assert m.test_sum_builtin(sum, []) == 0
-
-
-def test_async_callbacks():
-    # serves as state for async callback
-    class Item:
-        def __init__(self, value):
-            self.value = value
-
-    res = []
-
-    # generate stateful lambda that will store result in `res`
-    def gen_f():
-        s = Item(3)
-        return lambda j: res.append(s.value + j)
-
-    # do some work async
-    work = [1, 2, 3, 4]
-    m.test_async_callback(gen_f(), work)
-    # wait until work is done
-    from time import sleep
-
-    sleep(0.5)
-    assert sum(res) == sum(x + 3 for x in work)
-
-
-def test_async_async_callbacks():
-    t = Thread(target=test_async_callbacks)
-    t.start()
-    t.join()
-
-
-def test_callback_num_times():
-    # Super-simple micro-benchmarking related to PR #2919.
-    # Example runtimes (Intel Xeon 2.2GHz, fully optimized):
-    #   num_millions  1, repeats  2:  0.1 secs
-    #   num_millions 20, repeats 10: 11.5 secs
-    one_million = 1000000
-    num_millions = 1  # Try 20 for actual micro-benchmarking.
-    repeats = 2  # Try 10.
-    rates = []
-    for rep in range(repeats):
-        t0 = time.time()
-        m.callback_num_times(lambda: None, num_millions * one_million)
-        td = time.time() - t0
-        rate = num_millions / td if td else 0
-        rates.append(rate)
-        if not rep:
-            print()
-        print(
-            f"callback_num_times: {num_millions:d} million / {td:.3f} seconds = {rate:.3f} million / second"
-        )
-    if len(rates) > 1:
-        print("Min    Mean   Max")
-        print(f"{min(rates):6.3f} {sum(rates) / len(rates):6.3f} {max(rates):6.3f}")
-
-
-def test_custom_func():
-    assert m.custom_function(4) == 36
-    assert m.roundtrip(m.custom_function)(4) == 36
-
-
-@pytest.mark.skipif(
-    m.custom_function2 is None, reason="Current PYBIND11_INTERNALS_VERSION too low"
-)
-def test_custom_func2():
-    assert m.custom_function2(3) == 27
-    assert m.roundtrip(m.custom_function2)(3) == 27
-
-
-def test_callback_docstring():
-    assert (
-        m.test_tuple_unpacking.__doc__.strip()
-        == "test_tuple_unpacking(arg0: Callable) -> object"
-    )
+import time
+from threading import Thread
+
+import pytest
+
+import env  # noqa: F401
+from pybind11_tests import callbacks as m
+from pybind11_tests import detailed_error_messages_enabled
+
+
+def test_callbacks():
+    from functools import partial
+
+    def func1():
+        return "func1"
+
+    def func2(a, b, c, d):
+        return "func2", a, b, c, d
+
+    def func3(a):
+        return f"func3({a})"
+
+    assert m.test_callback1(func1) == "func1"
+    assert m.test_callback2(func2) == ("func2", "Hello", "x", True, 5)
+    assert m.test_callback1(partial(func2, 1, 2, 3, 4)) == ("func2", 1, 2, 3, 4)
+    assert m.test_callback1(partial(func3, "partial")) == "func3(partial)"
+    assert m.test_callback3(lambda i: i + 1) == "func(43) = 44"
+
+    f = m.test_callback4()
+    assert f(43) == 44
+    f = m.test_callback5()
+    assert f(number=43) == 44
+
+
+def test_bound_method_callback():
+    # Bound Python method:
+    class MyClass:
+        def double(self, val):
+            return 2 * val
+
+    z = MyClass()
+    assert m.test_callback3(z.double) == "func(43) = 86"
+
+    z = m.CppBoundMethodTest()
+    assert m.test_callback3(z.triple) == "func(43) = 129"
+
+
+def test_keyword_args_and_generalized_unpacking():
+    def f(*args, **kwargs):
+        return args, kwargs
+
+    assert m.test_tuple_unpacking(f) == (("positional", 1, 2, 3, 4, 5, 6), {})
+    assert m.test_dict_unpacking(f) == (
+        ("positional", 1),
+        {"key": "value", "a": 1, "b": 2},
+    )
+    assert m.test_keyword_args(f) == ((), {"x": 10, "y": 20})
+    assert m.test_unpacking_and_keywords1(f) == ((1, 2), {"c": 3, "d": 4})
+    assert m.test_unpacking_and_keywords2(f) == (
+        ("positional", 1, 2, 3, 4, 5),
+        {"key": "value", "a": 1, "b": 2, "c": 3, "d": 4, "e": 5},
+    )
+
+    with pytest.raises(TypeError) as excinfo:
+        m.test_unpacking_error1(f)
+    assert "Got multiple values for keyword argument" in str(excinfo.value)
+
+    with pytest.raises(TypeError) as excinfo:
+        m.test_unpacking_error2(f)
+    assert "Got multiple values for keyword argument" in str(excinfo.value)
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m.test_arg_conversion_error1(f)
+    assert str(excinfo.value) == "Unable to convert call argument " + (
+        "'1' of type 'UnregisteredType' to Python object"
+        if detailed_error_messages_enabled
+        else "'1' to Python object (#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)"
+    )
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m.test_arg_conversion_error2(f)
+    assert str(excinfo.value) == "Unable to convert call argument " + (
+        "'expected_name' of type 'UnregisteredType' to Python object"
+        if detailed_error_messages_enabled
+        else "'expected_name' to Python object "
+        "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)"
+    )
+
+
+def test_lambda_closure_cleanup():
+    m.test_lambda_closure_cleanup()
+    cstats = m.payload_cstats()
+    assert cstats.alive() == 0
+    assert cstats.copy_constructions == 1
+    assert cstats.move_constructions >= 1
+
+
+def test_cpp_callable_cleanup():
+    alive_counts = m.test_cpp_callable_cleanup()
+    assert alive_counts == [0, 1, 2, 1, 2, 1, 0]
+
+
+def test_cpp_function_roundtrip():
+    """Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer"""
+
+    assert (
+        m.test_dummy_function(m.dummy_function) == "matches dummy_function: eval(1) = 2"
+    )
+    assert (
+        m.test_dummy_function(m.roundtrip(m.dummy_function))
+        == "matches dummy_function: eval(1) = 2"
+    )
+    assert (
+        m.test_dummy_function(m.dummy_function_overloaded)
+        == "matches dummy_function: eval(1) = 2"
+    )
+    assert m.roundtrip(None, expect_none=True) is None
+    assert (
+        m.test_dummy_function(lambda x: x + 2)
+        == "can't convert to function pointer: eval(1) = 3"
+    )
+
+    with pytest.raises(TypeError) as excinfo:
+        m.test_dummy_function(m.dummy_function2)
+    assert "incompatible function arguments" in str(excinfo.value)
+
+    with pytest.raises(TypeError) as excinfo:
+        m.test_dummy_function(lambda x, y: x + y)
+    assert any(
+        s in str(excinfo.value)
+        for s in ("missing 1 required positional argument", "takes exactly 2 arguments")
+    )
+
+
+def test_function_signatures(doc):
+    assert doc(m.test_callback3) == "test_callback3(arg0: Callable[[int], int]) -> str"
+    assert doc(m.test_callback4) == "test_callback4() -> Callable[[int], int]"
+
+
+def test_movable_object():
+    assert m.callback_with_movable(lambda _: None) is True
+
+
+@pytest.mark.skipif(
+    "env.PYPY",
+    reason="PyPy segfaults on here. See discussion on #1413.",
+)
+def test_python_builtins():
+    """Test if python builtins like sum() can be used as callbacks"""
+    assert m.test_sum_builtin(sum, [1, 2, 3]) == 6
+    assert m.test_sum_builtin(sum, []) == 0
+
+
+def test_async_callbacks():
+    # serves as state for async callback
+    class Item:
+        def __init__(self, value):
+            self.value = value
+
+    res = []
+
+    # generate stateful lambda that will store result in `res`
+    def gen_f():
+        s = Item(3)
+        return lambda j: res.append(s.value + j)
+
+    # do some work async
+    work = [1, 2, 3, 4]
+    m.test_async_callback(gen_f(), work)
+    # wait until work is done
+    from time import sleep
+
+    sleep(0.5)
+    assert sum(res) == sum(x + 3 for x in work)
+
+
+def test_async_async_callbacks():
+    t = Thread(target=test_async_callbacks)
+    t.start()
+    t.join()
+
+
+def test_callback_num_times():
+    # Super-simple micro-benchmarking related to PR #2919.
+    # Example runtimes (Intel Xeon 2.2GHz, fully optimized):
+    #   num_millions  1, repeats  2:  0.1 secs
+    #   num_millions 20, repeats 10: 11.5 secs
+    one_million = 1000000
+    num_millions = 1  # Try 20 for actual micro-benchmarking.
+    repeats = 2  # Try 10.
+    rates = []
+    for rep in range(repeats):
+        t0 = time.time()
+        m.callback_num_times(lambda: None, num_millions * one_million)
+        td = time.time() - t0
+        rate = num_millions / td if td else 0
+        rates.append(rate)
+        if not rep:
+            print()
+        print(
+            f"callback_num_times: {num_millions:d} million / {td:.3f} seconds = {rate:.3f} million / second"
+        )
+    if len(rates) > 1:
+        print("Min    Mean   Max")
+        print(f"{min(rates):6.3f} {sum(rates) / len(rates):6.3f} {max(rates):6.3f}")
+
+
+def test_custom_func():
+    assert m.custom_function(4) == 36
+    assert m.roundtrip(m.custom_function)(4) == 36
+
+
+@pytest.mark.skipif(
+    m.custom_function2 is None, reason="Current PYBIND11_INTERNALS_VERSION too low"
+)
+def test_custom_func2():
+    assert m.custom_function2(3) == 27
+    assert m.roundtrip(m.custom_function2)(3) == 27
+
+
+def test_callback_docstring():
+    assert (
+        m.test_tuple_unpacking.__doc__.strip()
+        == "test_tuple_unpacking(arg0: Callable) -> object"
+    )

third_party/CityFlow/extern/pybind11/tests/test_chrono.cpp

@@ -1,81 +1,81 @@
-/*
-    tests/test_chrono.cpp -- test conversions to/from std::chrono types
-
-    Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
-                       Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/chrono.h>
-
-#include "pybind11_tests.h"
-
-#include <chrono>
-
-struct different_resolutions {
-    using time_point_h = std::chrono::time_point<std::chrono::system_clock, std::chrono::hours>;
-    using time_point_m = std::chrono::time_point<std::chrono::system_clock, std::chrono::minutes>;
-    using time_point_s = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
-    using time_point_ms
-        = std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>;
-    using time_point_us
-        = std::chrono::time_point<std::chrono::system_clock, std::chrono::microseconds>;
-    time_point_h timestamp_h;
-    time_point_m timestamp_m;
-    time_point_s timestamp_s;
-    time_point_ms timestamp_ms;
-    time_point_us timestamp_us;
-};
-
-TEST_SUBMODULE(chrono, m) {
-    using system_time = std::chrono::system_clock::time_point;
-    using steady_time = std::chrono::steady_clock::time_point;
-
-    using timespan = std::chrono::duration<int64_t, std::nano>;
-    using timestamp = std::chrono::time_point<std::chrono::system_clock, timespan>;
-
-    // test_chrono_system_clock
-    // Return the current time off the wall clock
-    m.def("test_chrono1", []() { return std::chrono::system_clock::now(); });
-
-    // test_chrono_system_clock_roundtrip
-    // Round trip the passed in system clock time
-    m.def("test_chrono2", [](system_time t) { return t; });
-
-    // test_chrono_duration_roundtrip
-    // Round trip the passed in duration
-    m.def("test_chrono3", [](std::chrono::system_clock::duration d) { return d; });
-
-    // test_chrono_duration_subtraction_equivalence
-    // Difference between two passed in time_points
-    m.def("test_chrono4", [](system_time a, system_time b) { return a - b; });
-
-    // test_chrono_steady_clock
-    // Return the current time off the steady_clock
-    m.def("test_chrono5", []() { return std::chrono::steady_clock::now(); });
-
-    // test_chrono_steady_clock_roundtrip
-    // Round trip a steady clock timepoint
-    m.def("test_chrono6", [](steady_time t) { return t; });
-
-    // test_floating_point_duration
-    // Roundtrip a duration in microseconds from a float argument
-    m.def("test_chrono7", [](std::chrono::microseconds t) { return t; });
-    // Float durations (issue #719)
-    m.def("test_chrono_float_diff",
-          [](std::chrono::duration<float> a, std::chrono::duration<float> b) { return a - b; });
-
-    m.def("test_nano_timepoint",
-          [](timestamp start, timespan delta) -> timestamp { return start + delta; });
-
-    // Test different resolutions
-    py::class_<different_resolutions>(m, "different_resolutions")
-        .def(py::init<>())
-        .def_readwrite("timestamp_h", &different_resolutions::timestamp_h)
-        .def_readwrite("timestamp_m", &different_resolutions::timestamp_m)
-        .def_readwrite("timestamp_s", &different_resolutions::timestamp_s)
-        .def_readwrite("timestamp_ms", &different_resolutions::timestamp_ms)
-        .def_readwrite("timestamp_us", &different_resolutions::timestamp_us);
-}
+/*
+    tests/test_chrono.cpp -- test conversions to/from std::chrono types
+
+    Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
+                       Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/chrono.h>
+
+#include "pybind11_tests.h"
+
+#include <chrono>
+
+struct different_resolutions {
+    using time_point_h = std::chrono::time_point<std::chrono::system_clock, std::chrono::hours>;
+    using time_point_m = std::chrono::time_point<std::chrono::system_clock, std::chrono::minutes>;
+    using time_point_s = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
+    using time_point_ms
+        = std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>;
+    using time_point_us
+        = std::chrono::time_point<std::chrono::system_clock, std::chrono::microseconds>;
+    time_point_h timestamp_h;
+    time_point_m timestamp_m;
+    time_point_s timestamp_s;
+    time_point_ms timestamp_ms;
+    time_point_us timestamp_us;
+};
+
+TEST_SUBMODULE(chrono, m) {
+    using system_time = std::chrono::system_clock::time_point;
+    using steady_time = std::chrono::steady_clock::time_point;
+
+    using timespan = std::chrono::duration<int64_t, std::nano>;
+    using timestamp = std::chrono::time_point<std::chrono::system_clock, timespan>;
+
+    // test_chrono_system_clock
+    // Return the current time off the wall clock
+    m.def("test_chrono1", []() { return std::chrono::system_clock::now(); });
+
+    // test_chrono_system_clock_roundtrip
+    // Round trip the passed in system clock time
+    m.def("test_chrono2", [](system_time t) { return t; });
+
+    // test_chrono_duration_roundtrip
+    // Round trip the passed in duration
+    m.def("test_chrono3", [](std::chrono::system_clock::duration d) { return d; });
+
+    // test_chrono_duration_subtraction_equivalence
+    // Difference between two passed in time_points
+    m.def("test_chrono4", [](system_time a, system_time b) { return a - b; });
+
+    // test_chrono_steady_clock
+    // Return the current time off the steady_clock
+    m.def("test_chrono5", []() { return std::chrono::steady_clock::now(); });
+
+    // test_chrono_steady_clock_roundtrip
+    // Round trip a steady clock timepoint
+    m.def("test_chrono6", [](steady_time t) { return t; });
+
+    // test_floating_point_duration
+    // Roundtrip a duration in microseconds from a float argument
+    m.def("test_chrono7", [](std::chrono::microseconds t) { return t; });
+    // Float durations (issue #719)
+    m.def("test_chrono_float_diff",
+          [](std::chrono::duration<float> a, std::chrono::duration<float> b) { return a - b; });
+
+    m.def("test_nano_timepoint",
+          [](timestamp start, timespan delta) -> timestamp { return start + delta; });
+
+    // Test different resolutions
+    py::class_<different_resolutions>(m, "different_resolutions")
+        .def(py::init<>())
+        .def_readwrite("timestamp_h", &different_resolutions::timestamp_h)
+        .def_readwrite("timestamp_m", &different_resolutions::timestamp_m)
+        .def_readwrite("timestamp_s", &different_resolutions::timestamp_s)
+        .def_readwrite("timestamp_ms", &different_resolutions::timestamp_ms)
+        .def_readwrite("timestamp_us", &different_resolutions::timestamp_us);
+}

third_party/CityFlow/extern/pybind11/tests/test_chrono.py

@@ -1,205 +1,205 @@
-import datetime
-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import chrono as m
-
-
-def test_chrono_system_clock():
-    # Get the time from both c++ and datetime
-    date0 = datetime.datetime.today()
-    date1 = m.test_chrono1()
-    date2 = datetime.datetime.today()
-
-    # The returned value should be a datetime
-    assert isinstance(date1, datetime.datetime)
-
-    # The numbers should vary by a very small amount (time it took to execute)
-    diff_python = abs(date2 - date0)
-    diff = abs(date1 - date2)
-
-    # There should never be a days difference
-    assert diff.days == 0
-
-    # Since datetime.datetime.today() calls time.time(), and on some platforms
-    # that has 1 second accuracy, we compare this way
-    assert diff.seconds <= diff_python.seconds
-
-
-def test_chrono_system_clock_roundtrip():
-    date1 = datetime.datetime.today()
-
-    # Roundtrip the time
-    date2 = m.test_chrono2(date1)
-
-    # The returned value should be a datetime
-    assert isinstance(date2, datetime.datetime)
-
-    # They should be identical (no information lost on roundtrip)
-    diff = abs(date1 - date2)
-    assert diff == datetime.timedelta(0)
-
-
-def test_chrono_system_clock_roundtrip_date():
-    date1 = datetime.date.today()
-
-    # Roundtrip the time
-    datetime2 = m.test_chrono2(date1)
-    date2 = datetime2.date()
-    time2 = datetime2.time()
-
-    # The returned value should be a datetime
-    assert isinstance(datetime2, datetime.datetime)
-    assert isinstance(date2, datetime.date)
-    assert isinstance(time2, datetime.time)
-
-    # They should be identical (no information lost on roundtrip)
-    diff = abs(date1 - date2)
-    assert diff.days == 0
-    assert diff.seconds == 0
-    assert diff.microseconds == 0
-
-    # Year, Month & Day should be the same after the round trip
-    assert date1 == date2
-
-    # There should be no time information
-    assert time2.hour == 0
-    assert time2.minute == 0
-    assert time2.second == 0
-    assert time2.microsecond == 0
-
-
-SKIP_TZ_ENV_ON_WIN = pytest.mark.skipif(
-    "env.WIN", reason="TZ environment variable only supported on POSIX"
-)
-
-
-@pytest.mark.parametrize(
-    "time1",
-    [
-        datetime.datetime.today().time(),
-        datetime.time(0, 0, 0),
-        datetime.time(0, 0, 0, 1),
-        datetime.time(0, 28, 45, 109827),
-        datetime.time(0, 59, 59, 999999),
-        datetime.time(1, 0, 0),
-        datetime.time(5, 59, 59, 0),
-        datetime.time(5, 59, 59, 1),
-    ],
-)
-@pytest.mark.parametrize(
-    "tz",
-    [
-        None,
-        pytest.param("Europe/Brussels", marks=SKIP_TZ_ENV_ON_WIN),
-        pytest.param("Asia/Pyongyang", marks=SKIP_TZ_ENV_ON_WIN),
-        pytest.param("America/New_York", marks=SKIP_TZ_ENV_ON_WIN),
-    ],
-)
-def test_chrono_system_clock_roundtrip_time(time1, tz, monkeypatch):
-    if tz is not None:
-        monkeypatch.setenv("TZ", f"/usr/share/zoneinfo/{tz}")
-
-    # Roundtrip the time
-    datetime2 = m.test_chrono2(time1)
-    date2 = datetime2.date()
-    time2 = datetime2.time()
-
-    # The returned value should be a datetime
-    assert isinstance(datetime2, datetime.datetime)
-    assert isinstance(date2, datetime.date)
-    assert isinstance(time2, datetime.time)
-
-    # Hour, Minute, Second & Microsecond should be the same after the round trip
-    assert time1 == time2
-
-    # There should be no date information (i.e. date = python base date)
-    assert date2.year == 1970
-    assert date2.month == 1
-    assert date2.day == 1
-
-
-def test_chrono_duration_roundtrip():
-    # Get the difference between two times (a timedelta)
-    date1 = datetime.datetime.today()
-    date2 = datetime.datetime.today()
-    diff = date2 - date1
-
-    # Make sure this is a timedelta
-    assert isinstance(diff, datetime.timedelta)
-
-    cpp_diff = m.test_chrono3(diff)
-
-    assert cpp_diff == diff
-
-    # Negative timedelta roundtrip
-    diff = datetime.timedelta(microseconds=-1)
-    cpp_diff = m.test_chrono3(diff)
-
-    assert cpp_diff == diff
-
-
-def test_chrono_duration_subtraction_equivalence():
-    date1 = datetime.datetime.today()
-    date2 = datetime.datetime.today()
-
-    diff = date2 - date1
-    cpp_diff = m.test_chrono4(date2, date1)
-
-    assert cpp_diff == diff
-
-
-def test_chrono_duration_subtraction_equivalence_date():
-    date1 = datetime.date.today()
-    date2 = datetime.date.today()
-
-    diff = date2 - date1
-    cpp_diff = m.test_chrono4(date2, date1)
-
-    assert cpp_diff == diff
-
-
-def test_chrono_steady_clock():
-    time1 = m.test_chrono5()
-    assert isinstance(time1, datetime.timedelta)
-
-
-def test_chrono_steady_clock_roundtrip():
-    time1 = datetime.timedelta(days=10, seconds=10, microseconds=100)
-    time2 = m.test_chrono6(time1)
-
-    assert isinstance(time2, datetime.timedelta)
-
-    # They should be identical (no information lost on roundtrip)
-    assert time1 == time2
-
-
-def test_floating_point_duration():
-    # Test using a floating point number in seconds
-    time = m.test_chrono7(35.525123)
-
-    assert isinstance(time, datetime.timedelta)
-
-    assert time.seconds == 35
-    assert 525122 <= time.microseconds <= 525123
-
-    diff = m.test_chrono_float_diff(43.789012, 1.123456)
-    assert diff.seconds == 42
-    assert 665556 <= diff.microseconds <= 665557
-
-
-def test_nano_timepoint():
-    time = datetime.datetime.now()
-    time1 = m.test_nano_timepoint(time, datetime.timedelta(seconds=60))
-    assert time1 == time + datetime.timedelta(seconds=60)
-
-
-def test_chrono_different_resolutions():
-    resolutions = m.different_resolutions()
-    time = datetime.datetime.now()
-    resolutions.timestamp_h = time
-    resolutions.timestamp_m = time
-    resolutions.timestamp_s = time
-    resolutions.timestamp_ms = time
-    resolutions.timestamp_us = time
+import datetime
+
+import pytest
+
+import env  # noqa: F401
+from pybind11_tests import chrono as m
+
+
+def test_chrono_system_clock():
+    # Get the time from both c++ and datetime
+    date0 = datetime.datetime.today()
+    date1 = m.test_chrono1()
+    date2 = datetime.datetime.today()
+
+    # The returned value should be a datetime
+    assert isinstance(date1, datetime.datetime)
+
+    # The numbers should vary by a very small amount (time it took to execute)
+    diff_python = abs(date2 - date0)
+    diff = abs(date1 - date2)
+
+    # There should never be a days difference
+    assert diff.days == 0
+
+    # Since datetime.datetime.today() calls time.time(), and on some platforms
+    # that has 1 second accuracy, we compare this way
+    assert diff.seconds <= diff_python.seconds
+
+
+def test_chrono_system_clock_roundtrip():
+    date1 = datetime.datetime.today()
+
+    # Roundtrip the time
+    date2 = m.test_chrono2(date1)
+
+    # The returned value should be a datetime
+    assert isinstance(date2, datetime.datetime)
+
+    # They should be identical (no information lost on roundtrip)
+    diff = abs(date1 - date2)
+    assert diff == datetime.timedelta(0)
+
+
+def test_chrono_system_clock_roundtrip_date():
+    date1 = datetime.date.today()
+
+    # Roundtrip the time
+    datetime2 = m.test_chrono2(date1)
+    date2 = datetime2.date()
+    time2 = datetime2.time()
+
+    # The returned value should be a datetime
+    assert isinstance(datetime2, datetime.datetime)
+    assert isinstance(date2, datetime.date)
+    assert isinstance(time2, datetime.time)
+
+    # They should be identical (no information lost on roundtrip)
+    diff = abs(date1 - date2)
+    assert diff.days == 0
+    assert diff.seconds == 0
+    assert diff.microseconds == 0
+
+    # Year, Month & Day should be the same after the round trip
+    assert date1 == date2
+
+    # There should be no time information
+    assert time2.hour == 0
+    assert time2.minute == 0
+    assert time2.second == 0
+    assert time2.microsecond == 0
+
+
+SKIP_TZ_ENV_ON_WIN = pytest.mark.skipif(
+    "env.WIN", reason="TZ environment variable only supported on POSIX"
+)
+
+
+@pytest.mark.parametrize(
+    "time1",
+    [
+        datetime.datetime.today().time(),
+        datetime.time(0, 0, 0),
+        datetime.time(0, 0, 0, 1),
+        datetime.time(0, 28, 45, 109827),
+        datetime.time(0, 59, 59, 999999),
+        datetime.time(1, 0, 0),
+        datetime.time(5, 59, 59, 0),
+        datetime.time(5, 59, 59, 1),
+    ],
+)
+@pytest.mark.parametrize(
+    "tz",
+    [
+        None,
+        pytest.param("Europe/Brussels", marks=SKIP_TZ_ENV_ON_WIN),
+        pytest.param("Asia/Pyongyang", marks=SKIP_TZ_ENV_ON_WIN),
+        pytest.param("America/New_York", marks=SKIP_TZ_ENV_ON_WIN),
+    ],
+)
+def test_chrono_system_clock_roundtrip_time(time1, tz, monkeypatch):
+    if tz is not None:
+        monkeypatch.setenv("TZ", f"/usr/share/zoneinfo/{tz}")
+
+    # Roundtrip the time
+    datetime2 = m.test_chrono2(time1)
+    date2 = datetime2.date()
+    time2 = datetime2.time()
+
+    # The returned value should be a datetime
+    assert isinstance(datetime2, datetime.datetime)
+    assert isinstance(date2, datetime.date)
+    assert isinstance(time2, datetime.time)
+
+    # Hour, Minute, Second & Microsecond should be the same after the round trip
+    assert time1 == time2
+
+    # There should be no date information (i.e. date = python base date)
+    assert date2.year == 1970
+    assert date2.month == 1
+    assert date2.day == 1
+
+
+def test_chrono_duration_roundtrip():
+    # Get the difference between two times (a timedelta)
+    date1 = datetime.datetime.today()
+    date2 = datetime.datetime.today()
+    diff = date2 - date1
+
+    # Make sure this is a timedelta
+    assert isinstance(diff, datetime.timedelta)
+
+    cpp_diff = m.test_chrono3(diff)
+
+    assert cpp_diff == diff
+
+    # Negative timedelta roundtrip
+    diff = datetime.timedelta(microseconds=-1)
+    cpp_diff = m.test_chrono3(diff)
+
+    assert cpp_diff == diff
+
+
+def test_chrono_duration_subtraction_equivalence():
+    date1 = datetime.datetime.today()
+    date2 = datetime.datetime.today()
+
+    diff = date2 - date1
+    cpp_diff = m.test_chrono4(date2, date1)
+
+    assert cpp_diff == diff
+
+
+def test_chrono_duration_subtraction_equivalence_date():
+    date1 = datetime.date.today()
+    date2 = datetime.date.today()
+
+    diff = date2 - date1
+    cpp_diff = m.test_chrono4(date2, date1)
+
+    assert cpp_diff == diff
+
+
+def test_chrono_steady_clock():
+    time1 = m.test_chrono5()
+    assert isinstance(time1, datetime.timedelta)
+
+
+def test_chrono_steady_clock_roundtrip():
+    time1 = datetime.timedelta(days=10, seconds=10, microseconds=100)
+    time2 = m.test_chrono6(time1)
+
+    assert isinstance(time2, datetime.timedelta)
+
+    # They should be identical (no information lost on roundtrip)
+    assert time1 == time2
+
+
+def test_floating_point_duration():
+    # Test using a floating point number in seconds
+    time = m.test_chrono7(35.525123)
+
+    assert isinstance(time, datetime.timedelta)
+
+    assert time.seconds == 35
+    assert 525122 <= time.microseconds <= 525123
+
+    diff = m.test_chrono_float_diff(43.789012, 1.123456)
+    assert diff.seconds == 42
+    assert 665556 <= diff.microseconds <= 665557
+
+
+def test_nano_timepoint():
+    time = datetime.datetime.now()
+    time1 = m.test_nano_timepoint(time, datetime.timedelta(seconds=60))
+    assert time1 == time + datetime.timedelta(seconds=60)
+
+
+def test_chrono_different_resolutions():
+    resolutions = m.different_resolutions()
+    time = datetime.datetime.now()
+    resolutions.timestamp_h = time
+    resolutions.timestamp_m = time
+    resolutions.timestamp_s = time
+    resolutions.timestamp_ms = time
+    resolutions.timestamp_us = time

third_party/CityFlow/extern/pybind11/tests/test_class.cpp

@@ -1,657 +1,657 @@
-/*
-    tests/test_class.cpp -- test py::class_ definitions and basic functionality
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#if defined(__INTEL_COMPILER) && __cplusplus >= 201703L
-// Intel compiler requires a separate header file to support aligned new operators
-// and does not set the __cpp_aligned_new feature macro.
-// This header needs to be included before pybind11.
-#    include <aligned_new>
-#endif
-
-#include <pybind11/stl.h>
-
-#include "constructor_stats.h"
-#include "local_bindings.h"
-#include "pybind11_tests.h"
-
-#include <utility>
-
-PYBIND11_WARNING_DISABLE_MSVC(4324)
-//     warning C4324: structure was padded due to alignment specifier
-
-// test_brace_initialization
-struct NoBraceInitialization {
-    explicit NoBraceInitialization(std::vector<int> v) : vec{std::move(v)} {}
-    template <typename T>
-    NoBraceInitialization(std::initializer_list<T> l) : vec(l) {}
-
-    std::vector<int> vec;
-};
-
-namespace test_class {
-namespace pr4220_tripped_over_this { // PR #4227
-
-template <int>
-struct SoEmpty {};
-
-template <typename T>
-std::string get_msg(const T &) {
-    return "This is really only meant to exercise successful compilation.";
-}
-
-using Empty0 = SoEmpty<0x0>;
-
-void bind_empty0(py::module_ &m) {
-    py::class_<Empty0>(m, "Empty0").def(py::init<>()).def("get_msg", get_msg<Empty0>);
-}
-
-} // namespace pr4220_tripped_over_this
-} // namespace test_class
-
-TEST_SUBMODULE(class_, m) {
-    m.def("obj_class_name", [](py::handle obj) { return py::detail::obj_class_name(obj.ptr()); });
-
-    // test_instance
-    struct NoConstructor {
-        NoConstructor() = default;
-        NoConstructor(const NoConstructor &) = default;
-        NoConstructor(NoConstructor &&) = default;
-        static NoConstructor *new_instance() {
-            auto *ptr = new NoConstructor();
-            print_created(ptr, "via new_instance");
-            return ptr;
-        }
-        ~NoConstructor() { print_destroyed(this); }
-    };
-    struct NoConstructorNew {
-        NoConstructorNew() = default;
-        NoConstructorNew(const NoConstructorNew &) = default;
-        NoConstructorNew(NoConstructorNew &&) = default;
-        static NoConstructorNew *new_instance() {
-            auto *ptr = new NoConstructorNew();
-            print_created(ptr, "via new_instance");
-            return ptr;
-        }
-        ~NoConstructorNew() { print_destroyed(this); }
-    };
-
-    py::class_<NoConstructor>(m, "NoConstructor")
-        .def_static("new_instance", &NoConstructor::new_instance, "Return an instance");
-
-    py::class_<NoConstructorNew>(m, "NoConstructorNew")
-        .def(py::init([]() { return nullptr; })) // Need a NOOP __init__
-        .def_static("__new__",
-                    [](const py::object &) { return NoConstructorNew::new_instance(); });
-
-    // test_inheritance
-    class Pet {
-    public:
-        Pet(const std::string &name, const std::string &species)
-            : m_name(name), m_species(species) {}
-        std::string name() const { return m_name; }
-        std::string species() const { return m_species; }
-
-    private:
-        std::string m_name;
-        std::string m_species;
-    };
-
-    class Dog : public Pet {
-    public:
-        explicit Dog(const std::string &name) : Pet(name, "dog") {}
-        std::string bark() const { return "Woof!"; }
-    };
-
-    class Rabbit : public Pet {
-    public:
-        explicit Rabbit(const std::string &name) : Pet(name, "parrot") {}
-    };
-
-    class Hamster : public Pet {
-    public:
-        explicit Hamster(const std::string &name) : Pet(name, "rodent") {}
-    };
-
-    class Chimera : public Pet {
-        Chimera() : Pet("Kimmy", "chimera") {}
-    };
-
-    py::class_<Pet> pet_class(m, "Pet");
-    pet_class.def(py::init<std::string, std::string>())
-        .def("name", &Pet::name)
-        .def("species", &Pet::species);
-
-    /* One way of declaring a subclass relationship: reference parent's class_ object */
-    py::class_<Dog>(m, "Dog", pet_class).def(py::init<std::string>());
-
-    /* Another way of declaring a subclass relationship: reference parent's C++ type */
-    py::class_<Rabbit, Pet>(m, "Rabbit").def(py::init<std::string>());
-
-    /* And another: list parent in class template arguments */
-    py::class_<Hamster, Pet>(m, "Hamster").def(py::init<std::string>());
-
-    /* Constructors are not inherited by default */
-    py::class_<Chimera, Pet>(m, "Chimera");
-
-    m.def("pet_name_species",
-          [](const Pet &pet) { return pet.name() + " is a " + pet.species(); });
-    m.def("dog_bark", [](const Dog &dog) { return dog.bark(); });
-
-    // test_automatic_upcasting
-    struct BaseClass {
-        BaseClass() = default;
-        BaseClass(const BaseClass &) = default;
-        BaseClass(BaseClass &&) = default;
-        virtual ~BaseClass() = default;
-    };
-    struct DerivedClass1 : BaseClass {};
-    struct DerivedClass2 : BaseClass {};
-
-    py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
-    py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
-    py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());
-
-    m.def("return_class_1", []() -> BaseClass * { return new DerivedClass1(); });
-    m.def("return_class_2", []() -> BaseClass * { return new DerivedClass2(); });
-    m.def("return_class_n", [](int n) -> BaseClass * {
-        if (n == 1) {
-            return new DerivedClass1();
-        }
-        if (n == 2) {
-            return new DerivedClass2();
-        }
-        return new BaseClass();
-    });
-    m.def("return_none", []() -> BaseClass * { return nullptr; });
-
-    // test_isinstance
-    m.def("check_instances", [](const py::list &l) {
-        return py::make_tuple(py::isinstance<py::tuple>(l[0]),
-                              py::isinstance<py::dict>(l[1]),
-                              py::isinstance<Pet>(l[2]),
-                              py::isinstance<Pet>(l[3]),
-                              py::isinstance<Dog>(l[4]),
-                              py::isinstance<Rabbit>(l[5]),
-                              py::isinstance<UnregisteredType>(l[6]));
-    });
-
-    struct Invalid {};
-
-    // test_type
-    m.def("check_type", [](int category) {
-        // Currently not supported (via a fail at compile time)
-        // See https://github.com/pybind/pybind11/issues/2486
-        // if (category == 2)
-        //     return py::type::of<int>();
-        if (category == 1) {
-            return py::type::of<DerivedClass1>();
-        }
-        return py::type::of<Invalid>();
-    });
-
-    m.def("get_type_of", [](py::object ob) { return py::type::of(std::move(ob)); });
-
-    m.def("get_type_classic", [](py::handle h) { return h.get_type(); });
-
-    m.def("as_type", [](const py::object &ob) { return py::type(ob); });
-
-    // test_mismatched_holder
-    struct MismatchBase1 {};
-    struct MismatchDerived1 : MismatchBase1 {};
-
-    struct MismatchBase2 {};
-    struct MismatchDerived2 : MismatchBase2 {};
-
-    m.def("mismatched_holder_1", []() {
-        auto mod = py::module_::import("__main__");
-        py::class_<MismatchBase1, std::shared_ptr<MismatchBase1>>(mod, "MismatchBase1");
-        py::class_<MismatchDerived1, MismatchBase1>(mod, "MismatchDerived1");
-    });
-    m.def("mismatched_holder_2", []() {
-        auto mod = py::module_::import("__main__");
-        py::class_<MismatchBase2>(mod, "MismatchBase2");
-        py::class_<MismatchDerived2, std::shared_ptr<MismatchDerived2>, MismatchBase2>(
-            mod, "MismatchDerived2");
-    });
-
-    // test_override_static
-    // #511: problem with inheritance + overwritten def_static
-    struct MyBase {
-        static std::unique_ptr<MyBase> make() { return std::unique_ptr<MyBase>(new MyBase()); }
-    };
-
-    struct MyDerived : MyBase {
-        static std::unique_ptr<MyDerived> make() {
-            return std::unique_ptr<MyDerived>(new MyDerived());
-        }
-    };
-
-    py::class_<MyBase>(m, "MyBase").def_static("make", &MyBase::make);
-
-    py::class_<MyDerived, MyBase>(m, "MyDerived")
-        .def_static("make", &MyDerived::make)
-        .def_static("make2", &MyDerived::make);
-
-    // test_implicit_conversion_life_support
-    struct ConvertibleFromUserType {
-        int i;
-
-        explicit ConvertibleFromUserType(UserType u) : i(u.value()) {}
-    };
-
-    py::class_<ConvertibleFromUserType>(m, "AcceptsUserType").def(py::init<UserType>());
-    py::implicitly_convertible<UserType, ConvertibleFromUserType>();
-
-    m.def("implicitly_convert_argument", [](const ConvertibleFromUserType &r) { return r.i; });
-    m.def("implicitly_convert_variable", [](const py::object &o) {
-        // `o` is `UserType` and `r` is a reference to a temporary created by implicit
-        // conversion. This is valid when called inside a bound function because the temp
-        // object is attached to the same life support system as the arguments.
-        const auto &r = o.cast<const ConvertibleFromUserType &>();
-        return r.i;
-    });
-    m.add_object("implicitly_convert_variable_fail", [&] {
-        auto f = [](PyObject *, PyObject *args) -> PyObject * {
-            auto o = py::reinterpret_borrow<py::tuple>(args)[0];
-            try { // It should fail here because there is no life support.
-                o.cast<const ConvertibleFromUserType &>();
-            } catch (const py::cast_error &e) {
-                return py::str(e.what()).release().ptr();
-            }
-            return py::str().release().ptr();
-        };
-
-        auto *def = new PyMethodDef{"f", f, METH_VARARGS, nullptr};
-        py::capsule def_capsule(def,
-                                [](void *ptr) { delete reinterpret_cast<PyMethodDef *>(ptr); });
-        return py::reinterpret_steal<py::object>(
-            PyCFunction_NewEx(def, def_capsule.ptr(), m.ptr()));
-    }());
-
-    // test_operator_new_delete
-    struct HasOpNewDel {
-        std::uint64_t i;
-        static void *operator new(size_t s) {
-            py::print("A new", s);
-            return ::operator new(s);
-        }
-        static void *operator new(size_t s, void *ptr) {
-            py::print("A placement-new", s);
-            return ptr;
-        }
-        static void operator delete(void *p) {
-            py::print("A delete");
-            return ::operator delete(p);
-        }
-    };
-    struct HasOpNewDelSize {
-        std::uint32_t i;
-        static void *operator new(size_t s) {
-            py::print("B new", s);
-            return ::operator new(s);
-        }
-        static void *operator new(size_t s, void *ptr) {
-            py::print("B placement-new", s);
-            return ptr;
-        }
-        static void operator delete(void *p, size_t s) {
-            py::print("B delete", s);
-            return ::operator delete(p);
-        }
-    };
-    struct AliasedHasOpNewDelSize {
-        std::uint64_t i;
-        static void *operator new(size_t s) {
-            py::print("C new", s);
-            return ::operator new(s);
-        }
-        static void *operator new(size_t s, void *ptr) {
-            py::print("C placement-new", s);
-            return ptr;
-        }
-        static void operator delete(void *p, size_t s) {
-            py::print("C delete", s);
-            return ::operator delete(p);
-        }
-        virtual ~AliasedHasOpNewDelSize() = default;
-        AliasedHasOpNewDelSize() = default;
-        AliasedHasOpNewDelSize(const AliasedHasOpNewDelSize &) = delete;
-    };
-    struct PyAliasedHasOpNewDelSize : AliasedHasOpNewDelSize {
-        PyAliasedHasOpNewDelSize() = default;
-        explicit PyAliasedHasOpNewDelSize(int) {}
-        std::uint64_t j;
-    };
-    struct HasOpNewDelBoth {
-        std::uint32_t i[8];
-        static void *operator new(size_t s) {
-            py::print("D new", s);
-            return ::operator new(s);
-        }
-        static void *operator new(size_t s, void *ptr) {
-            py::print("D placement-new", s);
-            return ptr;
-        }
-        static void operator delete(void *p) {
-            py::print("D delete");
-            return ::operator delete(p);
-        }
-        static void operator delete(void *p, size_t s) {
-            py::print("D wrong delete", s);
-            return ::operator delete(p);
-        }
-    };
-    py::class_<HasOpNewDel>(m, "HasOpNewDel").def(py::init<>());
-    py::class_<HasOpNewDelSize>(m, "HasOpNewDelSize").def(py::init<>());
-    py::class_<HasOpNewDelBoth>(m, "HasOpNewDelBoth").def(py::init<>());
-    py::class_<AliasedHasOpNewDelSize, PyAliasedHasOpNewDelSize> aliased(m,
-                                                                         "AliasedHasOpNewDelSize");
-    aliased.def(py::init<>());
-    aliased.attr("size_noalias") = py::int_(sizeof(AliasedHasOpNewDelSize));
-    aliased.attr("size_alias") = py::int_(sizeof(PyAliasedHasOpNewDelSize));
-
-    // This test is actually part of test_local_bindings (test_duplicate_local), but we need a
-    // definition in a different compilation unit within the same module:
-    bind_local<LocalExternal, 17>(m, "LocalExternal", py::module_local());
-
-    // test_bind_protected_functions
-    class ProtectedA {
-    protected:
-        int foo() const { return value; }
-
-    private:
-        int value = 42;
-    };
-
-    class PublicistA : public ProtectedA {
-    public:
-        using ProtectedA::foo;
-    };
-
-    py::class_<ProtectedA>(m, "ProtectedA").def(py::init<>()).def("foo", &PublicistA::foo);
-
-    class ProtectedB {
-    public:
-        virtual ~ProtectedB() = default;
-        ProtectedB() = default;
-        ProtectedB(const ProtectedB &) = delete;
-
-    protected:
-        virtual int foo() const { return value; }
-        virtual void *void_foo() { return static_cast<void *>(&value); }
-        virtual void *get_self() { return static_cast<void *>(this); }
-
-    private:
-        int value = 42;
-    };
-
-    class TrampolineB : public ProtectedB {
-    public:
-        int foo() const override { PYBIND11_OVERRIDE(int, ProtectedB, foo, ); }
-        void *void_foo() override { PYBIND11_OVERRIDE(void *, ProtectedB, void_foo, ); }
-        void *get_self() override { PYBIND11_OVERRIDE(void *, ProtectedB, get_self, ); }
-    };
-
-    class PublicistB : public ProtectedB {
-    public:
-        // [workaround(intel)] = default does not work here
-        // Removing or defaulting this destructor results in linking errors with the Intel compiler
-        // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827)
-        ~PublicistB() override{}; // NOLINT(modernize-use-equals-default)
-        using ProtectedB::foo;
-        using ProtectedB::get_self;
-        using ProtectedB::void_foo;
-    };
-
-    m.def("read_foo", [](const void *original) {
-        const int *ptr = reinterpret_cast<const int *>(original);
-        return *ptr;
-    });
-
-    m.def("pointers_equal",
-          [](const void *original, const void *comparison) { return original == comparison; });
-
-    py::class_<ProtectedB, TrampolineB>(m, "ProtectedB")
-        .def(py::init<>())
-        .def("foo", &PublicistB::foo)
-        .def("void_foo", &PublicistB::void_foo)
-        .def("get_self", &PublicistB::get_self);
-
-    // test_brace_initialization
-    struct BraceInitialization {
-        int field1;
-        std::string field2;
-    };
-
-    py::class_<BraceInitialization>(m, "BraceInitialization")
-        .def(py::init<int, const std::string &>())
-        .def_readwrite("field1", &BraceInitialization::field1)
-        .def_readwrite("field2", &BraceInitialization::field2);
-    // We *don't* want to construct using braces when the given constructor argument maps to a
-    // constructor, because brace initialization could go to the wrong place (in particular when
-    // there is also an `initializer_list<T>`-accept constructor):
-    py::class_<NoBraceInitialization>(m, "NoBraceInitialization")
-        .def(py::init<std::vector<int>>())
-        .def_readonly("vec", &NoBraceInitialization::vec);
-
-    // test_reentrant_implicit_conversion_failure
-    // #1035: issue with runaway reentrant implicit conversion
-    struct BogusImplicitConversion {
-        BogusImplicitConversion(const BogusImplicitConversion &) = default;
-    };
-
-    py::class_<BogusImplicitConversion>(m, "BogusImplicitConversion")
-        .def(py::init<const BogusImplicitConversion &>());
-
-    py::implicitly_convertible<int, BogusImplicitConversion>();
-
-    // test_qualname
-    // #1166: nested class docstring doesn't show nested name
-    // Also related: tests that __qualname__ is set properly
-    struct NestBase {};
-    struct Nested {};
-    py::class_<NestBase> base(m, "NestBase");
-    base.def(py::init<>());
-    py::class_<Nested>(base, "Nested")
-        .def(py::init<>())
-        .def("fn", [](Nested &, int, NestBase &, Nested &) {})
-        .def(
-            "fa", [](Nested &, int, NestBase &, Nested &) {}, "a"_a, "b"_a, "c"_a);
-    base.def("g", [](NestBase &, Nested &) {});
-    base.def("h", []() { return NestBase(); });
-
-    // test_error_after_conversion
-    // The second-pass path through dispatcher() previously didn't
-    // remember which overload was used, and would crash trying to
-    // generate a useful error message
-
-    struct NotRegistered {};
-    struct StringWrapper {
-        std::string str;
-    };
-    m.def("test_error_after_conversions", [](int) {});
-    m.def("test_error_after_conversions",
-          [](const StringWrapper &) -> NotRegistered { return {}; });
-    py::class_<StringWrapper>(m, "StringWrapper").def(py::init<std::string>());
-    py::implicitly_convertible<std::string, StringWrapper>();
-
-#if defined(PYBIND11_CPP17)
-    struct alignas(1024) Aligned {
-        std::uintptr_t ptr() const { return (uintptr_t) this; }
-    };
-    py::class_<Aligned>(m, "Aligned").def(py::init<>()).def("ptr", &Aligned::ptr);
-#endif
-
-    // test_final
-    struct IsFinal final {};
-    py::class_<IsFinal>(m, "IsFinal", py::is_final());
-
-    // test_non_final_final
-    struct IsNonFinalFinal {};
-    py::class_<IsNonFinalFinal>(m, "IsNonFinalFinal", py::is_final());
-
-    // test_exception_rvalue_abort
-    struct PyPrintDestructor {
-        PyPrintDestructor() = default;
-        ~PyPrintDestructor() { py::print("Print from destructor"); }
-        void throw_something() { throw std::runtime_error("error"); }
-    };
-    py::class_<PyPrintDestructor>(m, "PyPrintDestructor")
-        .def(py::init<>())
-        .def("throw_something", &PyPrintDestructor::throw_something);
-
-    // test_multiple_instances_with_same_pointer
-    struct SamePointer {};
-    static SamePointer samePointer;
-    py::class_<SamePointer, std::unique_ptr<SamePointer, py::nodelete>>(m, "SamePointer")
-        .def(py::init([]() { return &samePointer; }));
-
-    struct Empty {};
-    py::class_<Empty>(m, "Empty").def(py::init<>());
-
-    // test_base_and_derived_nested_scope
-    struct BaseWithNested {
-        struct Nested {};
-    };
-
-    struct DerivedWithNested : BaseWithNested {
-        struct Nested {};
-    };
-
-    py::class_<BaseWithNested> baseWithNested_class(m, "BaseWithNested");
-    py::class_<DerivedWithNested, BaseWithNested> derivedWithNested_class(m, "DerivedWithNested");
-    py::class_<BaseWithNested::Nested>(baseWithNested_class, "Nested")
-        .def_static("get_name", []() { return "BaseWithNested::Nested"; });
-    py::class_<DerivedWithNested::Nested>(derivedWithNested_class, "Nested")
-        .def_static("get_name", []() { return "DerivedWithNested::Nested"; });
-
-    // test_register_duplicate_class
-    struct Duplicate {};
-    struct OtherDuplicate {};
-    struct DuplicateNested {};
-    struct OtherDuplicateNested {};
-
-    m.def("register_duplicate_class_name", [](const py::module_ &m) {
-        py::class_<Duplicate>(m, "Duplicate");
-        py::class_<OtherDuplicate>(m, "Duplicate");
-    });
-    m.def("register_duplicate_class_type", [](const py::module_ &m) {
-        py::class_<OtherDuplicate>(m, "OtherDuplicate");
-        py::class_<OtherDuplicate>(m, "YetAnotherDuplicate");
-    });
-    m.def("register_duplicate_nested_class_name", [](const py::object &gt) {
-        py::class_<DuplicateNested>(gt, "DuplicateNested");
-        py::class_<OtherDuplicateNested>(gt, "DuplicateNested");
-    });
-    m.def("register_duplicate_nested_class_type", [](const py::object &gt) {
-        py::class_<OtherDuplicateNested>(gt, "OtherDuplicateNested");
-        py::class_<OtherDuplicateNested>(gt, "YetAnotherDuplicateNested");
-    });
-
-    test_class::pr4220_tripped_over_this::bind_empty0(m);
-}
-
-template <int N>
-class BreaksBase {
-public:
-    virtual ~BreaksBase() = default;
-    BreaksBase() = default;
-    BreaksBase(const BreaksBase &) = delete;
-};
-template <int N>
-class BreaksTramp : public BreaksBase<N> {};
-// These should all compile just fine:
-using DoesntBreak1 = py::class_<BreaksBase<1>, std::unique_ptr<BreaksBase<1>>, BreaksTramp<1>>;
-using DoesntBreak2 = py::class_<BreaksBase<2>, BreaksTramp<2>, std::unique_ptr<BreaksBase<2>>>;
-using DoesntBreak3 = py::class_<BreaksBase<3>, std::unique_ptr<BreaksBase<3>>>;
-using DoesntBreak4 = py::class_<BreaksBase<4>, BreaksTramp<4>>;
-using DoesntBreak5 = py::class_<BreaksBase<5>>;
-using DoesntBreak6 = py::class_<BreaksBase<6>, std::shared_ptr<BreaksBase<6>>, BreaksTramp<6>>;
-using DoesntBreak7 = py::class_<BreaksBase<7>, BreaksTramp<7>, std::shared_ptr<BreaksBase<7>>>;
-using DoesntBreak8 = py::class_<BreaksBase<8>, std::shared_ptr<BreaksBase<8>>>;
-#define CHECK_BASE(N)                                                                             \
-    static_assert(std::is_same<typename DoesntBreak##N::type, BreaksBase<(N)>>::value,            \
-                  "DoesntBreak" #N " has wrong type!")
-CHECK_BASE(1);
-CHECK_BASE(2);
-CHECK_BASE(3);
-CHECK_BASE(4);
-CHECK_BASE(5);
-CHECK_BASE(6);
-CHECK_BASE(7);
-CHECK_BASE(8);
-#define CHECK_ALIAS(N)                                                                            \
-    static_assert(                                                                                \
-        DoesntBreak##N::has_alias                                                                 \
-            && std::is_same<typename DoesntBreak##N::type_alias, BreaksTramp<(N)>>::value,        \
-        "DoesntBreak" #N " has wrong type_alias!")
-#define CHECK_NOALIAS(N)                                                                          \
-    static_assert(!DoesntBreak##N::has_alias                                                      \
-                      && std::is_void<typename DoesntBreak##N::type_alias>::value,                \
-                  "DoesntBreak" #N " has type alias, but shouldn't!")
-CHECK_ALIAS(1);
-CHECK_ALIAS(2);
-CHECK_NOALIAS(3);
-CHECK_ALIAS(4);
-CHECK_NOALIAS(5);
-CHECK_ALIAS(6);
-CHECK_ALIAS(7);
-CHECK_NOALIAS(8);
-#define CHECK_HOLDER(N, TYPE)                                                                     \
-    static_assert(std::is_same<typename DoesntBreak##N::holder_type,                              \
-                               std::TYPE##_ptr<BreaksBase<(N)>>>::value,                          \
-                  "DoesntBreak" #N " has wrong holder_type!")
-CHECK_HOLDER(1, unique);
-CHECK_HOLDER(2, unique);
-CHECK_HOLDER(3, unique);
-CHECK_HOLDER(4, unique);
-CHECK_HOLDER(5, unique);
-CHECK_HOLDER(6, shared);
-CHECK_HOLDER(7, shared);
-CHECK_HOLDER(8, shared);
-
-// There's no nice way to test that these fail because they fail to compile; leave them here,
-// though, so that they can be manually tested by uncommenting them (and seeing that compilation
-// failures occurs).
-
-// We have to actually look into the type: the typedef alone isn't enough to instantiate the type:
-#define CHECK_BROKEN(N)                                                                           \
-    static_assert(std::is_same<typename Breaks##N::type, BreaksBase<-(N)>>::value,                \
-                  "Breaks1 has wrong type!");
-
-#ifdef PYBIND11_NEVER_DEFINED_EVER
-// Two holder classes:
-typedef py::
-    class_<BreaksBase<-1>, std::unique_ptr<BreaksBase<-1>>, std::unique_ptr<BreaksBase<-1>>>
-        Breaks1;
-CHECK_BROKEN(1);
-// Two aliases:
-typedef py::class_<BreaksBase<-2>, BreaksTramp<-2>, BreaksTramp<-2>> Breaks2;
-CHECK_BROKEN(2);
-// Holder + 2 aliases
-typedef py::
-    class_<BreaksBase<-3>, std::unique_ptr<BreaksBase<-3>>, BreaksTramp<-3>, BreaksTramp<-3>>
-        Breaks3;
-CHECK_BROKEN(3);
-// Alias + 2 holders
-typedef py::class_<BreaksBase<-4>,
-                   std::unique_ptr<BreaksBase<-4>>,
-                   BreaksTramp<-4>,
-                   std::shared_ptr<BreaksBase<-4>>>
-    Breaks4;
-CHECK_BROKEN(4);
-// Invalid option (not a subclass or holder)
-typedef py::class_<BreaksBase<-5>, BreaksTramp<-4>> Breaks5;
-CHECK_BROKEN(5);
-// Invalid option: multiple inheritance not supported:
-template <>
-struct BreaksBase<-8> : BreaksBase<-6>, BreaksBase<-7> {};
-typedef py::class_<BreaksBase<-8>, BreaksBase<-6>, BreaksBase<-7>> Breaks8;
-CHECK_BROKEN(8);
-#endif
+/*
+    tests/test_class.cpp -- test py::class_ definitions and basic functionality
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if defined(__INTEL_COMPILER) && __cplusplus >= 201703L
+// Intel compiler requires a separate header file to support aligned new operators
+// and does not set the __cpp_aligned_new feature macro.
+// This header needs to be included before pybind11.
+#    include <aligned_new>
+#endif
+
+#include <pybind11/stl.h>
+
+#include "constructor_stats.h"
+#include "local_bindings.h"
+#include "pybind11_tests.h"
+
+#include <utility>
+
+PYBIND11_WARNING_DISABLE_MSVC(4324)
+//     warning C4324: structure was padded due to alignment specifier
+
+// test_brace_initialization
+struct NoBraceInitialization {
+    explicit NoBraceInitialization(std::vector<int> v) : vec{std::move(v)} {}
+    template <typename T>
+    NoBraceInitialization(std::initializer_list<T> l) : vec(l) {}
+
+    std::vector<int> vec;
+};
+
+namespace test_class {
+namespace pr4220_tripped_over_this { // PR #4227
+
+template <int>
+struct SoEmpty {};
+
+template <typename T>
+std::string get_msg(const T &) {
+    return "This is really only meant to exercise successful compilation.";
+}
+
+using Empty0 = SoEmpty<0x0>;
+
+void bind_empty0(py::module_ &m) {
+    py::class_<Empty0>(m, "Empty0").def(py::init<>()).def("get_msg", get_msg<Empty0>);
+}
+
+} // namespace pr4220_tripped_over_this
+} // namespace test_class
+
+TEST_SUBMODULE(class_, m) {
+    m.def("obj_class_name", [](py::handle obj) { return py::detail::obj_class_name(obj.ptr()); });
+
+    // test_instance
+    struct NoConstructor {
+        NoConstructor() = default;
+        NoConstructor(const NoConstructor &) = default;
+        NoConstructor(NoConstructor &&) = default;
+        static NoConstructor *new_instance() {
+            auto *ptr = new NoConstructor();
+            print_created(ptr, "via new_instance");
+            return ptr;
+        }
+        ~NoConstructor() { print_destroyed(this); }
+    };
+    struct NoConstructorNew {
+        NoConstructorNew() = default;
+        NoConstructorNew(const NoConstructorNew &) = default;
+        NoConstructorNew(NoConstructorNew &&) = default;
+        static NoConstructorNew *new_instance() {
+            auto *ptr = new NoConstructorNew();
+            print_created(ptr, "via new_instance");
+            return ptr;
+        }
+        ~NoConstructorNew() { print_destroyed(this); }
+    };
+
+    py::class_<NoConstructor>(m, "NoConstructor")
+        .def_static("new_instance", &NoConstructor::new_instance, "Return an instance");
+
+    py::class_<NoConstructorNew>(m, "NoConstructorNew")
+        .def(py::init([]() { return nullptr; })) // Need a NOOP __init__
+        .def_static("__new__",
+                    [](const py::object &) { return NoConstructorNew::new_instance(); });
+
+    // test_inheritance
+    class Pet {
+    public:
+        Pet(const std::string &name, const std::string &species)
+            : m_name(name), m_species(species) {}
+        std::string name() const { return m_name; }
+        std::string species() const { return m_species; }
+
+    private:
+        std::string m_name;
+        std::string m_species;
+    };
+
+    class Dog : public Pet {
+    public:
+        explicit Dog(const std::string &name) : Pet(name, "dog") {}
+        std::string bark() const { return "Woof!"; }
+    };
+
+    class Rabbit : public Pet {
+    public:
+        explicit Rabbit(const std::string &name) : Pet(name, "parrot") {}
+    };
+
+    class Hamster : public Pet {
+    public:
+        explicit Hamster(const std::string &name) : Pet(name, "rodent") {}
+    };
+
+    class Chimera : public Pet {
+        Chimera() : Pet("Kimmy", "chimera") {}
+    };
+
+    py::class_<Pet> pet_class(m, "Pet");
+    pet_class.def(py::init<std::string, std::string>())
+        .def("name", &Pet::name)
+        .def("species", &Pet::species);
+
+    /* One way of declaring a subclass relationship: reference parent's class_ object */
+    py::class_<Dog>(m, "Dog", pet_class).def(py::init<std::string>());
+
+    /* Another way of declaring a subclass relationship: reference parent's C++ type */
+    py::class_<Rabbit, Pet>(m, "Rabbit").def(py::init<std::string>());
+
+    /* And another: list parent in class template arguments */
+    py::class_<Hamster, Pet>(m, "Hamster").def(py::init<std::string>());
+
+    /* Constructors are not inherited by default */
+    py::class_<Chimera, Pet>(m, "Chimera");
+
+    m.def("pet_name_species",
+          [](const Pet &pet) { return pet.name() + " is a " + pet.species(); });
+    m.def("dog_bark", [](const Dog &dog) { return dog.bark(); });
+
+    // test_automatic_upcasting
+    struct BaseClass {
+        BaseClass() = default;
+        BaseClass(const BaseClass &) = default;
+        BaseClass(BaseClass &&) = default;
+        virtual ~BaseClass() = default;
+    };
+    struct DerivedClass1 : BaseClass {};
+    struct DerivedClass2 : BaseClass {};
+
+    py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
+    py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
+    py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());
+
+    m.def("return_class_1", []() -> BaseClass * { return new DerivedClass1(); });
+    m.def("return_class_2", []() -> BaseClass * { return new DerivedClass2(); });
+    m.def("return_class_n", [](int n) -> BaseClass * {
+        if (n == 1) {
+            return new DerivedClass1();
+        }
+        if (n == 2) {
+            return new DerivedClass2();
+        }
+        return new BaseClass();
+    });
+    m.def("return_none", []() -> BaseClass * { return nullptr; });
+
+    // test_isinstance
+    m.def("check_instances", [](const py::list &l) {
+        return py::make_tuple(py::isinstance<py::tuple>(l[0]),
+                              py::isinstance<py::dict>(l[1]),
+                              py::isinstance<Pet>(l[2]),
+                              py::isinstance<Pet>(l[3]),
+                              py::isinstance<Dog>(l[4]),
+                              py::isinstance<Rabbit>(l[5]),
+                              py::isinstance<UnregisteredType>(l[6]));
+    });
+
+    struct Invalid {};
+
+    // test_type
+    m.def("check_type", [](int category) {
+        // Currently not supported (via a fail at compile time)
+        // See https://github.com/pybind/pybind11/issues/2486
+        // if (category == 2)
+        //     return py::type::of<int>();
+        if (category == 1) {
+            return py::type::of<DerivedClass1>();
+        }
+        return py::type::of<Invalid>();
+    });
+
+    m.def("get_type_of", [](py::object ob) { return py::type::of(std::move(ob)); });
+
+    m.def("get_type_classic", [](py::handle h) { return h.get_type(); });
+
+    m.def("as_type", [](const py::object &ob) { return py::type(ob); });
+
+    // test_mismatched_holder
+    struct MismatchBase1 {};
+    struct MismatchDerived1 : MismatchBase1 {};
+
+    struct MismatchBase2 {};
+    struct MismatchDerived2 : MismatchBase2 {};
+
+    m.def("mismatched_holder_1", []() {
+        auto mod = py::module_::import("__main__");
+        py::class_<MismatchBase1, std::shared_ptr<MismatchBase1>>(mod, "MismatchBase1");
+        py::class_<MismatchDerived1, MismatchBase1>(mod, "MismatchDerived1");
+    });
+    m.def("mismatched_holder_2", []() {
+        auto mod = py::module_::import("__main__");
+        py::class_<MismatchBase2>(mod, "MismatchBase2");
+        py::class_<MismatchDerived2, std::shared_ptr<MismatchDerived2>, MismatchBase2>(
+            mod, "MismatchDerived2");
+    });
+
+    // test_override_static
+    // #511: problem with inheritance + overwritten def_static
+    struct MyBase {
+        static std::unique_ptr<MyBase> make() { return std::unique_ptr<MyBase>(new MyBase()); }
+    };
+
+    struct MyDerived : MyBase {
+        static std::unique_ptr<MyDerived> make() {
+            return std::unique_ptr<MyDerived>(new MyDerived());
+        }
+    };
+
+    py::class_<MyBase>(m, "MyBase").def_static("make", &MyBase::make);
+
+    py::class_<MyDerived, MyBase>(m, "MyDerived")
+        .def_static("make", &MyDerived::make)
+        .def_static("make2", &MyDerived::make);
+
+    // test_implicit_conversion_life_support
+    struct ConvertibleFromUserType {
+        int i;
+
+        explicit ConvertibleFromUserType(UserType u) : i(u.value()) {}
+    };
+
+    py::class_<ConvertibleFromUserType>(m, "AcceptsUserType").def(py::init<UserType>());
+    py::implicitly_convertible<UserType, ConvertibleFromUserType>();
+
+    m.def("implicitly_convert_argument", [](const ConvertibleFromUserType &r) { return r.i; });
+    m.def("implicitly_convert_variable", [](const py::object &o) {
+        // `o` is `UserType` and `r` is a reference to a temporary created by implicit
+        // conversion. This is valid when called inside a bound function because the temp
+        // object is attached to the same life support system as the arguments.
+        const auto &r = o.cast<const ConvertibleFromUserType &>();
+        return r.i;
+    });
+    m.add_object("implicitly_convert_variable_fail", [&] {
+        auto f = [](PyObject *, PyObject *args) -> PyObject * {
+            auto o = py::reinterpret_borrow<py::tuple>(args)[0];
+            try { // It should fail here because there is no life support.
+                o.cast<const ConvertibleFromUserType &>();
+            } catch (const py::cast_error &e) {
+                return py::str(e.what()).release().ptr();
+            }
+            return py::str().release().ptr();
+        };
+
+        auto *def = new PyMethodDef{"f", f, METH_VARARGS, nullptr};
+        py::capsule def_capsule(def,
+                                [](void *ptr) { delete reinterpret_cast<PyMethodDef *>(ptr); });
+        return py::reinterpret_steal<py::object>(
+            PyCFunction_NewEx(def, def_capsule.ptr(), m.ptr()));
+    }());
+
+    // test_operator_new_delete
+    struct HasOpNewDel {
+        std::uint64_t i;
+        static void *operator new(size_t s) {
+            py::print("A new", s);
+            return ::operator new(s);
+        }
+        static void *operator new(size_t s, void *ptr) {
+            py::print("A placement-new", s);
+            return ptr;
+        }
+        static void operator delete(void *p) {
+            py::print("A delete");
+            return ::operator delete(p);
+        }
+    };
+    struct HasOpNewDelSize {
+        std::uint32_t i;
+        static void *operator new(size_t s) {
+            py::print("B new", s);
+            return ::operator new(s);
+        }
+        static void *operator new(size_t s, void *ptr) {
+            py::print("B placement-new", s);
+            return ptr;
+        }
+        static void operator delete(void *p, size_t s) {
+            py::print("B delete", s);
+            return ::operator delete(p);
+        }
+    };
+    struct AliasedHasOpNewDelSize {
+        std::uint64_t i;
+        static void *operator new(size_t s) {
+            py::print("C new", s);
+            return ::operator new(s);
+        }
+        static void *operator new(size_t s, void *ptr) {
+            py::print("C placement-new", s);
+            return ptr;
+        }
+        static void operator delete(void *p, size_t s) {
+            py::print("C delete", s);
+            return ::operator delete(p);
+        }
+        virtual ~AliasedHasOpNewDelSize() = default;
+        AliasedHasOpNewDelSize() = default;
+        AliasedHasOpNewDelSize(const AliasedHasOpNewDelSize &) = delete;
+    };
+    struct PyAliasedHasOpNewDelSize : AliasedHasOpNewDelSize {
+        PyAliasedHasOpNewDelSize() = default;
+        explicit PyAliasedHasOpNewDelSize(int) {}
+        std::uint64_t j;
+    };
+    struct HasOpNewDelBoth {
+        std::uint32_t i[8];
+        static void *operator new(size_t s) {
+            py::print("D new", s);
+            return ::operator new(s);
+        }
+        static void *operator new(size_t s, void *ptr) {
+            py::print("D placement-new", s);
+            return ptr;
+        }
+        static void operator delete(void *p) {
+            py::print("D delete");
+            return ::operator delete(p);
+        }
+        static void operator delete(void *p, size_t s) {
+            py::print("D wrong delete", s);
+            return ::operator delete(p);
+        }
+    };
+    py::class_<HasOpNewDel>(m, "HasOpNewDel").def(py::init<>());
+    py::class_<HasOpNewDelSize>(m, "HasOpNewDelSize").def(py::init<>());
+    py::class_<HasOpNewDelBoth>(m, "HasOpNewDelBoth").def(py::init<>());
+    py::class_<AliasedHasOpNewDelSize, PyAliasedHasOpNewDelSize> aliased(m,
+                                                                         "AliasedHasOpNewDelSize");
+    aliased.def(py::init<>());
+    aliased.attr("size_noalias") = py::int_(sizeof(AliasedHasOpNewDelSize));
+    aliased.attr("size_alias") = py::int_(sizeof(PyAliasedHasOpNewDelSize));
+
+    // This test is actually part of test_local_bindings (test_duplicate_local), but we need a
+    // definition in a different compilation unit within the same module:
+    bind_local<LocalExternal, 17>(m, "LocalExternal", py::module_local());
+
+    // test_bind_protected_functions
+    class ProtectedA {
+    protected:
+        int foo() const { return value; }
+
+    private:
+        int value = 42;
+    };
+
+    class PublicistA : public ProtectedA {
+    public:
+        using ProtectedA::foo;
+    };
+
+    py::class_<ProtectedA>(m, "ProtectedA").def(py::init<>()).def("foo", &PublicistA::foo);
+
+    class ProtectedB {
+    public:
+        virtual ~ProtectedB() = default;
+        ProtectedB() = default;
+        ProtectedB(const ProtectedB &) = delete;
+
+    protected:
+        virtual int foo() const { return value; }
+        virtual void *void_foo() { return static_cast<void *>(&value); }
+        virtual void *get_self() { return static_cast<void *>(this); }
+
+    private:
+        int value = 42;
+    };
+
+    class TrampolineB : public ProtectedB {
+    public:
+        int foo() const override { PYBIND11_OVERRIDE(int, ProtectedB, foo, ); }
+        void *void_foo() override { PYBIND11_OVERRIDE(void *, ProtectedB, void_foo, ); }
+        void *get_self() override { PYBIND11_OVERRIDE(void *, ProtectedB, get_self, ); }
+    };
+
+    class PublicistB : public ProtectedB {
+    public:
+        // [workaround(intel)] = default does not work here
+        // Removing or defaulting this destructor results in linking errors with the Intel compiler
+        // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827)
+        ~PublicistB() override{}; // NOLINT(modernize-use-equals-default)
+        using ProtectedB::foo;
+        using ProtectedB::get_self;
+        using ProtectedB::void_foo;
+    };
+
+    m.def("read_foo", [](const void *original) {
+        const int *ptr = reinterpret_cast<const int *>(original);
+        return *ptr;
+    });
+
+    m.def("pointers_equal",
+          [](const void *original, const void *comparison) { return original == comparison; });
+
+    py::class_<ProtectedB, TrampolineB>(m, "ProtectedB")
+        .def(py::init<>())
+        .def("foo", &PublicistB::foo)
+        .def("void_foo", &PublicistB::void_foo)
+        .def("get_self", &PublicistB::get_self);
+
+    // test_brace_initialization
+    struct BraceInitialization {
+        int field1;
+        std::string field2;
+    };
+
+    py::class_<BraceInitialization>(m, "BraceInitialization")
+        .def(py::init<int, const std::string &>())
+        .def_readwrite("field1", &BraceInitialization::field1)
+        .def_readwrite("field2", &BraceInitialization::field2);
+    // We *don't* want to construct using braces when the given constructor argument maps to a
+    // constructor, because brace initialization could go to the wrong place (in particular when
+    // there is also an `initializer_list<T>`-accept constructor):
+    py::class_<NoBraceInitialization>(m, "NoBraceInitialization")
+        .def(py::init<std::vector<int>>())
+        .def_readonly("vec", &NoBraceInitialization::vec);
+
+    // test_reentrant_implicit_conversion_failure
+    // #1035: issue with runaway reentrant implicit conversion
+    struct BogusImplicitConversion {
+        BogusImplicitConversion(const BogusImplicitConversion &) = default;
+    };
+
+    py::class_<BogusImplicitConversion>(m, "BogusImplicitConversion")
+        .def(py::init<const BogusImplicitConversion &>());
+
+    py::implicitly_convertible<int, BogusImplicitConversion>();
+
+    // test_qualname
+    // #1166: nested class docstring doesn't show nested name
+    // Also related: tests that __qualname__ is set properly
+    struct NestBase {};
+    struct Nested {};
+    py::class_<NestBase> base(m, "NestBase");
+    base.def(py::init<>());
+    py::class_<Nested>(base, "Nested")
+        .def(py::init<>())
+        .def("fn", [](Nested &, int, NestBase &, Nested &) {})
+        .def(
+            "fa", [](Nested &, int, NestBase &, Nested &) {}, "a"_a, "b"_a, "c"_a);
+    base.def("g", [](NestBase &, Nested &) {});
+    base.def("h", []() { return NestBase(); });
+
+    // test_error_after_conversion
+    // The second-pass path through dispatcher() previously didn't
+    // remember which overload was used, and would crash trying to
+    // generate a useful error message
+
+    struct NotRegistered {};
+    struct StringWrapper {
+        std::string str;
+    };
+    m.def("test_error_after_conversions", [](int) {});
+    m.def("test_error_after_conversions",
+          [](const StringWrapper &) -> NotRegistered { return {}; });
+    py::class_<StringWrapper>(m, "StringWrapper").def(py::init<std::string>());
+    py::implicitly_convertible<std::string, StringWrapper>();
+
+#if defined(PYBIND11_CPP17)
+    struct alignas(1024) Aligned {
+        std::uintptr_t ptr() const { return (uintptr_t) this; }
+    };
+    py::class_<Aligned>(m, "Aligned").def(py::init<>()).def("ptr", &Aligned::ptr);
+#endif
+
+    // test_final
+    struct IsFinal final {};
+    py::class_<IsFinal>(m, "IsFinal", py::is_final());
+
+    // test_non_final_final
+    struct IsNonFinalFinal {};
+    py::class_<IsNonFinalFinal>(m, "IsNonFinalFinal", py::is_final());
+
+    // test_exception_rvalue_abort
+    struct PyPrintDestructor {
+        PyPrintDestructor() = default;
+        ~PyPrintDestructor() { py::print("Print from destructor"); }
+        void throw_something() { throw std::runtime_error("error"); }
+    };
+    py::class_<PyPrintDestructor>(m, "PyPrintDestructor")
+        .def(py::init<>())
+        .def("throw_something", &PyPrintDestructor::throw_something);
+
+    // test_multiple_instances_with_same_pointer
+    struct SamePointer {};
+    static SamePointer samePointer;
+    py::class_<SamePointer, std::unique_ptr<SamePointer, py::nodelete>>(m, "SamePointer")
+        .def(py::init([]() { return &samePointer; }));
+
+    struct Empty {};
+    py::class_<Empty>(m, "Empty").def(py::init<>());
+
+    // test_base_and_derived_nested_scope
+    struct BaseWithNested {
+        struct Nested {};
+    };
+
+    struct DerivedWithNested : BaseWithNested {
+        struct Nested {};
+    };
+
+    py::class_<BaseWithNested> baseWithNested_class(m, "BaseWithNested");
+    py::class_<DerivedWithNested, BaseWithNested> derivedWithNested_class(m, "DerivedWithNested");
+    py::class_<BaseWithNested::Nested>(baseWithNested_class, "Nested")
+        .def_static("get_name", []() { return "BaseWithNested::Nested"; });
+    py::class_<DerivedWithNested::Nested>(derivedWithNested_class, "Nested")
+        .def_static("get_name", []() { return "DerivedWithNested::Nested"; });
+
+    // test_register_duplicate_class
+    struct Duplicate {};
+    struct OtherDuplicate {};
+    struct DuplicateNested {};
+    struct OtherDuplicateNested {};
+
+    m.def("register_duplicate_class_name", [](const py::module_ &m) {
+        py::class_<Duplicate>(m, "Duplicate");
+        py::class_<OtherDuplicate>(m, "Duplicate");
+    });
+    m.def("register_duplicate_class_type", [](const py::module_ &m) {
+        py::class_<OtherDuplicate>(m, "OtherDuplicate");
+        py::class_<OtherDuplicate>(m, "YetAnotherDuplicate");
+    });
+    m.def("register_duplicate_nested_class_name", [](const py::object &gt) {
+        py::class_<DuplicateNested>(gt, "DuplicateNested");
+        py::class_<OtherDuplicateNested>(gt, "DuplicateNested");
+    });
+    m.def("register_duplicate_nested_class_type", [](const py::object &gt) {
+        py::class_<OtherDuplicateNested>(gt, "OtherDuplicateNested");
+        py::class_<OtherDuplicateNested>(gt, "YetAnotherDuplicateNested");
+    });
+
+    test_class::pr4220_tripped_over_this::bind_empty0(m);
+}
+
+template <int N>
+class BreaksBase {
+public:
+    virtual ~BreaksBase() = default;
+    BreaksBase() = default;
+    BreaksBase(const BreaksBase &) = delete;
+};
+template <int N>
+class BreaksTramp : public BreaksBase<N> {};
+// These should all compile just fine:
+using DoesntBreak1 = py::class_<BreaksBase<1>, std::unique_ptr<BreaksBase<1>>, BreaksTramp<1>>;
+using DoesntBreak2 = py::class_<BreaksBase<2>, BreaksTramp<2>, std::unique_ptr<BreaksBase<2>>>;
+using DoesntBreak3 = py::class_<BreaksBase<3>, std::unique_ptr<BreaksBase<3>>>;
+using DoesntBreak4 = py::class_<BreaksBase<4>, BreaksTramp<4>>;
+using DoesntBreak5 = py::class_<BreaksBase<5>>;
+using DoesntBreak6 = py::class_<BreaksBase<6>, std::shared_ptr<BreaksBase<6>>, BreaksTramp<6>>;
+using DoesntBreak7 = py::class_<BreaksBase<7>, BreaksTramp<7>, std::shared_ptr<BreaksBase<7>>>;
+using DoesntBreak8 = py::class_<BreaksBase<8>, std::shared_ptr<BreaksBase<8>>>;
+#define CHECK_BASE(N)                                                                             \
+    static_assert(std::is_same<typename DoesntBreak##N::type, BreaksBase<(N)>>::value,            \
+                  "DoesntBreak" #N " has wrong type!")
+CHECK_BASE(1);
+CHECK_BASE(2);
+CHECK_BASE(3);
+CHECK_BASE(4);
+CHECK_BASE(5);
+CHECK_BASE(6);
+CHECK_BASE(7);
+CHECK_BASE(8);
+#define CHECK_ALIAS(N)                                                                            \
+    static_assert(                                                                                \
+        DoesntBreak##N::has_alias                                                                 \
+            && std::is_same<typename DoesntBreak##N::type_alias, BreaksTramp<(N)>>::value,        \
+        "DoesntBreak" #N " has wrong type_alias!")
+#define CHECK_NOALIAS(N)                                                                          \
+    static_assert(!DoesntBreak##N::has_alias                                                      \
+                      && std::is_void<typename DoesntBreak##N::type_alias>::value,                \
+                  "DoesntBreak" #N " has type alias, but shouldn't!")
+CHECK_ALIAS(1);
+CHECK_ALIAS(2);
+CHECK_NOALIAS(3);
+CHECK_ALIAS(4);
+CHECK_NOALIAS(5);
+CHECK_ALIAS(6);
+CHECK_ALIAS(7);
+CHECK_NOALIAS(8);
+#define CHECK_HOLDER(N, TYPE)                                                                     \
+    static_assert(std::is_same<typename DoesntBreak##N::holder_type,                              \
+                               std::TYPE##_ptr<BreaksBase<(N)>>>::value,                          \
+                  "DoesntBreak" #N " has wrong holder_type!")
+CHECK_HOLDER(1, unique);
+CHECK_HOLDER(2, unique);
+CHECK_HOLDER(3, unique);
+CHECK_HOLDER(4, unique);
+CHECK_HOLDER(5, unique);
+CHECK_HOLDER(6, shared);
+CHECK_HOLDER(7, shared);
+CHECK_HOLDER(8, shared);
+
+// There's no nice way to test that these fail because they fail to compile; leave them here,
+// though, so that they can be manually tested by uncommenting them (and seeing that compilation
+// failures occurs).
+
+// We have to actually look into the type: the typedef alone isn't enough to instantiate the type:
+#define CHECK_BROKEN(N)                                                                           \
+    static_assert(std::is_same<typename Breaks##N::type, BreaksBase<-(N)>>::value,                \
+                  "Breaks1 has wrong type!");
+
+#ifdef PYBIND11_NEVER_DEFINED_EVER
+// Two holder classes:
+typedef py::
+    class_<BreaksBase<-1>, std::unique_ptr<BreaksBase<-1>>, std::unique_ptr<BreaksBase<-1>>>
+        Breaks1;
+CHECK_BROKEN(1);
+// Two aliases:
+typedef py::class_<BreaksBase<-2>, BreaksTramp<-2>, BreaksTramp<-2>> Breaks2;
+CHECK_BROKEN(2);
+// Holder + 2 aliases
+typedef py::
+    class_<BreaksBase<-3>, std::unique_ptr<BreaksBase<-3>>, BreaksTramp<-3>, BreaksTramp<-3>>
+        Breaks3;
+CHECK_BROKEN(3);
+// Alias + 2 holders
+typedef py::class_<BreaksBase<-4>,
+                   std::unique_ptr<BreaksBase<-4>>,
+                   BreaksTramp<-4>,
+                   std::shared_ptr<BreaksBase<-4>>>
+    Breaks4;
+CHECK_BROKEN(4);
+// Invalid option (not a subclass or holder)
+typedef py::class_<BreaksBase<-5>, BreaksTramp<-4>> Breaks5;
+CHECK_BROKEN(5);
+// Invalid option: multiple inheritance not supported:
+template <>
+struct BreaksBase<-8> : BreaksBase<-6>, BreaksBase<-7> {};
+typedef py::class_<BreaksBase<-8>, BreaksBase<-6>, BreaksBase<-7>> Breaks8;
+CHECK_BROKEN(8);
+#endif

third_party/CityFlow/extern/pybind11/tests/test_class.py

@@ -1,499 +1,499 @@
-from unittest import mock
-
-import pytest
-
-import env
-from pybind11_tests import ConstructorStats, UserType
-from pybind11_tests import class_ as m
-
-
-def test_obj_class_name():
-    expected_name = "UserType" if env.PYPY else "pybind11_tests.UserType"
-    assert m.obj_class_name(UserType(1)) == expected_name
-    assert m.obj_class_name(UserType) == expected_name
-
-
-def test_repr():
-    assert "pybind11_type" in repr(type(UserType))
-    assert "UserType" in repr(UserType)
-
-
-def test_instance(msg):
-    with pytest.raises(TypeError) as excinfo:
-        m.NoConstructor()
-    assert msg(excinfo.value) == "m.class_.NoConstructor: No constructor defined!"
-
-    instance = m.NoConstructor.new_instance()
-
-    cstats = ConstructorStats.get(m.NoConstructor)
-    assert cstats.alive() == 1
-    del instance
-    assert cstats.alive() == 0
-
-
-def test_instance_new():
-    instance = m.NoConstructorNew()  # .__new__(m.NoConstructor.__class__)
-    cstats = ConstructorStats.get(m.NoConstructorNew)
-    assert cstats.alive() == 1
-    del instance
-    assert cstats.alive() == 0
-
-
-def test_type():
-    assert m.check_type(1) == m.DerivedClass1
-    with pytest.raises(RuntimeError) as execinfo:
-        m.check_type(0)
-
-    assert "pybind11::detail::get_type_info: unable to find type info" in str(
-        execinfo.value
-    )
-    assert "Invalid" in str(execinfo.value)
-
-    # Currently not supported
-    # See https://github.com/pybind/pybind11/issues/2486
-    # assert m.check_type(2) == int
-
-
-def test_type_of_py():
-    assert m.get_type_of(1) == int
-    assert m.get_type_of(m.DerivedClass1()) == m.DerivedClass1
-    assert m.get_type_of(int) == type
-
-
-def test_type_of_classic():
-    assert m.get_type_classic(1) == int
-    assert m.get_type_classic(m.DerivedClass1()) == m.DerivedClass1
-    assert m.get_type_classic(int) == type
-
-
-def test_type_of_py_nodelete():
-    # If the above test deleted the class, this will segfault
-    assert m.get_type_of(m.DerivedClass1()) == m.DerivedClass1
-
-
-def test_as_type_py():
-    assert m.as_type(int) == int
-
-    with pytest.raises(TypeError):
-        assert m.as_type(1) == int
-
-    with pytest.raises(TypeError):
-        assert m.as_type(m.DerivedClass1()) == m.DerivedClass1
-
-
-def test_docstrings(doc):
-    assert doc(UserType) == "A `py::class_` type for testing"
-    assert UserType.__name__ == "UserType"
-    assert UserType.__module__ == "pybind11_tests"
-    assert UserType.get_value.__name__ == "get_value"
-    assert UserType.get_value.__module__ == "pybind11_tests"
-
-    assert (
-        doc(UserType.get_value)
-        == """
-        get_value(self: m.UserType) -> int
-
-        Get value using a method
-    """
-    )
-    assert doc(UserType.value) == "Get/set value using a property"
-
-    assert (
-        doc(m.NoConstructor.new_instance)
-        == """
-        new_instance() -> m.class_.NoConstructor
-
-        Return an instance
-    """
-    )
-
-
-def test_qualname(doc):
-    """Tests that a properly qualified name is set in __qualname__ and that
-    generated docstrings properly use it and the module name"""
-    assert m.NestBase.__qualname__ == "NestBase"
-    assert m.NestBase.Nested.__qualname__ == "NestBase.Nested"
-
-    assert (
-        doc(m.NestBase.__init__)
-        == """
-        __init__(self: m.class_.NestBase) -> None
-    """
-    )
-    assert (
-        doc(m.NestBase.g)
-        == """
-        g(self: m.class_.NestBase, arg0: m.class_.NestBase.Nested) -> None
-    """
-    )
-    assert (
-        doc(m.NestBase.Nested.__init__)
-        == """
-        __init__(self: m.class_.NestBase.Nested) -> None
-    """
-    )
-    assert (
-        doc(m.NestBase.Nested.fn)
-        == """
-        fn(self: m.class_.NestBase.Nested, arg0: int, arg1: m.class_.NestBase, arg2: m.class_.NestBase.Nested) -> None
-    """
-    )
-    assert (
-        doc(m.NestBase.Nested.fa)
-        == """
-        fa(self: m.class_.NestBase.Nested, a: int, b: m.class_.NestBase, c: m.class_.NestBase.Nested) -> None
-    """
-    )
-    assert m.NestBase.__module__ == "pybind11_tests.class_"
-    assert m.NestBase.Nested.__module__ == "pybind11_tests.class_"
-
-
-def test_inheritance(msg):
-    roger = m.Rabbit("Rabbit")
-    assert roger.name() + " is a " + roger.species() == "Rabbit is a parrot"
-    assert m.pet_name_species(roger) == "Rabbit is a parrot"
-
-    polly = m.Pet("Polly", "parrot")
-    assert polly.name() + " is a " + polly.species() == "Polly is a parrot"
-    assert m.pet_name_species(polly) == "Polly is a parrot"
-
-    molly = m.Dog("Molly")
-    assert molly.name() + " is a " + molly.species() == "Molly is a dog"
-    assert m.pet_name_species(molly) == "Molly is a dog"
-
-    fred = m.Hamster("Fred")
-    assert fred.name() + " is a " + fred.species() == "Fred is a rodent"
-
-    assert m.dog_bark(molly) == "Woof!"
-
-    with pytest.raises(TypeError) as excinfo:
-        m.dog_bark(polly)
-    assert (
-        msg(excinfo.value)
-        == """
-        dog_bark(): incompatible function arguments. The following argument types are supported:
-            1. (arg0: m.class_.Dog) -> str
-
-        Invoked with: <m.class_.Pet object at 0>
-    """
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        m.Chimera("lion", "goat")
-    assert "No constructor defined!" in str(excinfo.value)
-
-
-def test_inheritance_init(msg):
-    # Single base
-    class Python(m.Pet):
-        def __init__(self):
-            pass
-
-    with pytest.raises(TypeError) as exc_info:
-        Python()
-    expected = "m.class_.Pet.__init__() must be called when overriding __init__"
-    assert msg(exc_info.value) == expected
-
-    # Multiple bases
-    class RabbitHamster(m.Rabbit, m.Hamster):
-        def __init__(self):
-            m.Rabbit.__init__(self, "RabbitHamster")
-
-    with pytest.raises(TypeError) as exc_info:
-        RabbitHamster()
-    expected = "m.class_.Hamster.__init__() must be called when overriding __init__"
-    assert msg(exc_info.value) == expected
-
-
-@pytest.mark.parametrize(
-    "mock_return_value", [None, (1, 2, 3), m.Pet("Polly", "parrot"), m.Dog("Molly")]
-)
-def test_mock_new(mock_return_value):
-    with mock.patch.object(
-        m.Pet, "__new__", return_value=mock_return_value
-    ) as mock_new:
-        obj = m.Pet("Noname", "Nospecies")
-    assert obj is mock_return_value
-    mock_new.assert_called_once_with(m.Pet, "Noname", "Nospecies")
-
-
-def test_automatic_upcasting():
-    assert type(m.return_class_1()).__name__ == "DerivedClass1"
-    assert type(m.return_class_2()).__name__ == "DerivedClass2"
-    assert type(m.return_none()).__name__ == "NoneType"
-    # Repeat these a few times in a random order to ensure no invalid caching is applied
-    assert type(m.return_class_n(1)).__name__ == "DerivedClass1"
-    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
-    assert type(m.return_class_n(0)).__name__ == "BaseClass"
-    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
-    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
-    assert type(m.return_class_n(0)).__name__ == "BaseClass"
-    assert type(m.return_class_n(1)).__name__ == "DerivedClass1"
-
-
-def test_isinstance():
-    objects = [(), {}, m.Pet("Polly", "parrot")] + [m.Dog("Molly")] * 4
-    expected = (True, True, True, True, True, False, False)
-    assert m.check_instances(objects) == expected
-
-
-def test_mismatched_holder():
-    import re
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.mismatched_holder_1()
-    assert re.match(
-        'generic_type: type ".*MismatchDerived1" does not have a non-default '
-        'holder type while its base ".*MismatchBase1" does',
-        str(excinfo.value),
-    )
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.mismatched_holder_2()
-    assert re.match(
-        'generic_type: type ".*MismatchDerived2" has a non-default holder type '
-        'while its base ".*MismatchBase2" does not',
-        str(excinfo.value),
-    )
-
-
-def test_override_static():
-    """#511: problem with inheritance + overwritten def_static"""
-    b = m.MyBase.make()
-    d1 = m.MyDerived.make2()
-    d2 = m.MyDerived.make()
-
-    assert isinstance(b, m.MyBase)
-    assert isinstance(d1, m.MyDerived)
-    assert isinstance(d2, m.MyDerived)
-
-
-def test_implicit_conversion_life_support():
-    """Ensure the lifetime of temporary objects created for implicit conversions"""
-    assert m.implicitly_convert_argument(UserType(5)) == 5
-    assert m.implicitly_convert_variable(UserType(5)) == 5
-
-    assert "outside a bound function" in m.implicitly_convert_variable_fail(UserType(5))
-
-
-def test_operator_new_delete(capture):
-    """Tests that class-specific operator new/delete functions are invoked"""
-
-    class SubAliased(m.AliasedHasOpNewDelSize):
-        pass
-
-    with capture:
-        a = m.HasOpNewDel()
-        b = m.HasOpNewDelSize()
-        d = m.HasOpNewDelBoth()
-    assert (
-        capture
-        == """
-        A new 8
-        B new 4
-        D new 32
-    """
-    )
-    sz_alias = str(m.AliasedHasOpNewDelSize.size_alias)
-    sz_noalias = str(m.AliasedHasOpNewDelSize.size_noalias)
-    with capture:
-        c = m.AliasedHasOpNewDelSize()
-        c2 = SubAliased()
-    assert capture == ("C new " + sz_noalias + "\n" + "C new " + sz_alias + "\n")
-
-    with capture:
-        del a
-        pytest.gc_collect()
-        del b
-        pytest.gc_collect()
-        del d
-        pytest.gc_collect()
-    assert (
-        capture
-        == """
-        A delete
-        B delete 4
-        D delete
-    """
-    )
-
-    with capture:
-        del c
-        pytest.gc_collect()
-        del c2
-        pytest.gc_collect()
-    assert capture == ("C delete " + sz_noalias + "\n" + "C delete " + sz_alias + "\n")
-
-
-def test_bind_protected_functions():
-    """Expose protected member functions to Python using a helper class"""
-    a = m.ProtectedA()
-    assert a.foo() == 42
-
-    b = m.ProtectedB()
-    assert b.foo() == 42
-    assert m.read_foo(b.void_foo()) == 42
-    assert m.pointers_equal(b.get_self(), b)
-
-    class C(m.ProtectedB):
-        def __init__(self):
-            m.ProtectedB.__init__(self)
-
-        def foo(self):
-            return 0
-
-    c = C()
-    assert c.foo() == 0
-
-
-def test_brace_initialization():
-    """Tests that simple POD classes can be constructed using C++11 brace initialization"""
-    a = m.BraceInitialization(123, "test")
-    assert a.field1 == 123
-    assert a.field2 == "test"
-
-    # Tests that a non-simple class doesn't get brace initialization (if the
-    # class defines an initializer_list constructor, in particular, it would
-    # win over the expected constructor).
-    b = m.NoBraceInitialization([123, 456])
-    assert b.vec == [123, 456]
-
-
-@pytest.mark.xfail("env.PYPY")
-def test_class_refcount():
-    """Instances must correctly increase/decrease the reference count of their types (#1029)"""
-    from sys import getrefcount
-
-    class PyDog(m.Dog):
-        pass
-
-    for cls in m.Dog, PyDog:
-        refcount_1 = getrefcount(cls)
-        molly = [cls("Molly") for _ in range(10)]
-        refcount_2 = getrefcount(cls)
-
-        del molly
-        pytest.gc_collect()
-        refcount_3 = getrefcount(cls)
-
-        assert refcount_1 == refcount_3
-        assert refcount_2 > refcount_1
-
-
-def test_reentrant_implicit_conversion_failure(msg):
-    # ensure that there is no runaway reentrant implicit conversion (#1035)
-    with pytest.raises(TypeError) as excinfo:
-        m.BogusImplicitConversion(0)
-    assert (
-        msg(excinfo.value)
-        == """
-        __init__(): incompatible constructor arguments. The following argument types are supported:
-            1. m.class_.BogusImplicitConversion(arg0: m.class_.BogusImplicitConversion)
-
-        Invoked with: 0
-    """
-    )
-
-
-def test_error_after_conversions():
-    with pytest.raises(TypeError) as exc_info:
-        m.test_error_after_conversions("hello")
-    assert str(exc_info.value).startswith(
-        "Unable to convert function return value to a Python type!"
-    )
-
-
-def test_aligned():
-    if hasattr(m, "Aligned"):
-        p = m.Aligned().ptr()
-        assert p % 1024 == 0
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2742
-@pytest.mark.xfail("env.PYPY")
-def test_final():
-    with pytest.raises(TypeError) as exc_info:
-
-        class PyFinalChild(m.IsFinal):
-            pass
-
-    assert str(exc_info.value).endswith("is not an acceptable base type")
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2742
-@pytest.mark.xfail("env.PYPY")
-def test_non_final_final():
-    with pytest.raises(TypeError) as exc_info:
-
-        class PyNonFinalFinalChild(m.IsNonFinalFinal):
-            pass
-
-    assert str(exc_info.value).endswith("is not an acceptable base type")
-
-
-# https://github.com/pybind/pybind11/issues/1878
-def test_exception_rvalue_abort():
-    with pytest.raises(RuntimeError):
-        m.PyPrintDestructor().throw_something()
-
-
-# https://github.com/pybind/pybind11/issues/1568
-def test_multiple_instances_with_same_pointer():
-    n = 100
-    instances = [m.SamePointer() for _ in range(n)]
-    for i in range(n):
-        # We need to reuse the same allocated memory for with a different type,
-        # to ensure the bug in `deregister_instance_impl` is detected. Otherwise
-        # `Py_TYPE(self) == Py_TYPE(it->second)` will still succeed, even though
-        # the `instance` is already deleted.
-        instances[i] = m.Empty()
-    # No assert: if this does not trigger the error
-    #   pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
-    # and just completes without crashing, we're good.
-
-
-# https://github.com/pybind/pybind11/issues/1624
-def test_base_and_derived_nested_scope():
-    assert issubclass(m.DerivedWithNested, m.BaseWithNested)
-    assert m.BaseWithNested.Nested != m.DerivedWithNested.Nested
-    assert m.BaseWithNested.Nested.get_name() == "BaseWithNested::Nested"
-    assert m.DerivedWithNested.Nested.get_name() == "DerivedWithNested::Nested"
-
-
-def test_register_duplicate_class():
-    import types
-
-    module_scope = types.ModuleType("module_scope")
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_class_name(module_scope)
-    expected = (
-        'generic_type: cannot initialize type "Duplicate": '
-        "an object with that name is already defined"
-    )
-    assert str(exc_info.value) == expected
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_class_type(module_scope)
-    expected = 'generic_type: type "YetAnotherDuplicate" is already registered!'
-    assert str(exc_info.value) == expected
-
-    class ClassScope:
-        pass
-
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_nested_class_name(ClassScope)
-    expected = (
-        'generic_type: cannot initialize type "DuplicateNested": '
-        "an object with that name is already defined"
-    )
-    assert str(exc_info.value) == expected
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_nested_class_type(ClassScope)
-    expected = 'generic_type: type "YetAnotherDuplicateNested" is already registered!'
-    assert str(exc_info.value) == expected
-
-
-def test_pr4220_tripped_over_this():
-    assert (
-        m.Empty0().get_msg()
-        == "This is really only meant to exercise successful compilation."
-    )
+from unittest import mock
+
+import pytest
+
+import env
+from pybind11_tests import ConstructorStats, UserType
+from pybind11_tests import class_ as m
+
+
+def test_obj_class_name():
+    expected_name = "UserType" if env.PYPY else "pybind11_tests.UserType"
+    assert m.obj_class_name(UserType(1)) == expected_name
+    assert m.obj_class_name(UserType) == expected_name
+
+
+def test_repr():
+    assert "pybind11_type" in repr(type(UserType))
+    assert "UserType" in repr(UserType)
+
+
+def test_instance(msg):
+    with pytest.raises(TypeError) as excinfo:
+        m.NoConstructor()
+    assert msg(excinfo.value) == "m.class_.NoConstructor: No constructor defined!"
+
+    instance = m.NoConstructor.new_instance()
+
+    cstats = ConstructorStats.get(m.NoConstructor)
+    assert cstats.alive() == 1
+    del instance
+    assert cstats.alive() == 0
+
+
+def test_instance_new():
+    instance = m.NoConstructorNew()  # .__new__(m.NoConstructor.__class__)
+    cstats = ConstructorStats.get(m.NoConstructorNew)
+    assert cstats.alive() == 1
+    del instance
+    assert cstats.alive() == 0
+
+
+def test_type():
+    assert m.check_type(1) == m.DerivedClass1
+    with pytest.raises(RuntimeError) as execinfo:
+        m.check_type(0)
+
+    assert "pybind11::detail::get_type_info: unable to find type info" in str(
+        execinfo.value
+    )
+    assert "Invalid" in str(execinfo.value)
+
+    # Currently not supported
+    # See https://github.com/pybind/pybind11/issues/2486
+    # assert m.check_type(2) == int
+
+
+def test_type_of_py():
+    assert m.get_type_of(1) == int
+    assert m.get_type_of(m.DerivedClass1()) == m.DerivedClass1
+    assert m.get_type_of(int) == type
+
+
+def test_type_of_classic():
+    assert m.get_type_classic(1) == int
+    assert m.get_type_classic(m.DerivedClass1()) == m.DerivedClass1
+    assert m.get_type_classic(int) == type
+
+
+def test_type_of_py_nodelete():
+    # If the above test deleted the class, this will segfault
+    assert m.get_type_of(m.DerivedClass1()) == m.DerivedClass1
+
+
+def test_as_type_py():
+    assert m.as_type(int) == int
+
+    with pytest.raises(TypeError):
+        assert m.as_type(1) == int
+
+    with pytest.raises(TypeError):
+        assert m.as_type(m.DerivedClass1()) == m.DerivedClass1
+
+
+def test_docstrings(doc):
+    assert doc(UserType) == "A `py::class_` type for testing"
+    assert UserType.__name__ == "UserType"
+    assert UserType.__module__ == "pybind11_tests"
+    assert UserType.get_value.__name__ == "get_value"
+    assert UserType.get_value.__module__ == "pybind11_tests"
+
+    assert (
+        doc(UserType.get_value)
+        == """
+        get_value(self: m.UserType) -> int
+
+        Get value using a method
+    """
+    )
+    assert doc(UserType.value) == "Get/set value using a property"
+
+    assert (
+        doc(m.NoConstructor.new_instance)
+        == """
+        new_instance() -> m.class_.NoConstructor
+
+        Return an instance
+    """
+    )
+
+
+def test_qualname(doc):
+    """Tests that a properly qualified name is set in __qualname__ and that
+    generated docstrings properly use it and the module name"""
+    assert m.NestBase.__qualname__ == "NestBase"
+    assert m.NestBase.Nested.__qualname__ == "NestBase.Nested"
+
+    assert (
+        doc(m.NestBase.__init__)
+        == """
+        __init__(self: m.class_.NestBase) -> None
+    """
+    )
+    assert (
+        doc(m.NestBase.g)
+        == """
+        g(self: m.class_.NestBase, arg0: m.class_.NestBase.Nested) -> None
+    """
+    )
+    assert (
+        doc(m.NestBase.Nested.__init__)
+        == """
+        __init__(self: m.class_.NestBase.Nested) -> None
+    """
+    )
+    assert (
+        doc(m.NestBase.Nested.fn)
+        == """
+        fn(self: m.class_.NestBase.Nested, arg0: int, arg1: m.class_.NestBase, arg2: m.class_.NestBase.Nested) -> None
+    """
+    )
+    assert (
+        doc(m.NestBase.Nested.fa)
+        == """
+        fa(self: m.class_.NestBase.Nested, a: int, b: m.class_.NestBase, c: m.class_.NestBase.Nested) -> None
+    """
+    )
+    assert m.NestBase.__module__ == "pybind11_tests.class_"
+    assert m.NestBase.Nested.__module__ == "pybind11_tests.class_"
+
+
+def test_inheritance(msg):
+    roger = m.Rabbit("Rabbit")
+    assert roger.name() + " is a " + roger.species() == "Rabbit is a parrot"
+    assert m.pet_name_species(roger) == "Rabbit is a parrot"
+
+    polly = m.Pet("Polly", "parrot")
+    assert polly.name() + " is a " + polly.species() == "Polly is a parrot"
+    assert m.pet_name_species(polly) == "Polly is a parrot"
+
+    molly = m.Dog("Molly")
+    assert molly.name() + " is a " + molly.species() == "Molly is a dog"
+    assert m.pet_name_species(molly) == "Molly is a dog"
+
+    fred = m.Hamster("Fred")
+    assert fred.name() + " is a " + fred.species() == "Fred is a rodent"
+
+    assert m.dog_bark(molly) == "Woof!"
+
+    with pytest.raises(TypeError) as excinfo:
+        m.dog_bark(polly)
+    assert (
+        msg(excinfo.value)
+        == """
+        dog_bark(): incompatible function arguments. The following argument types are supported:
+            1. (arg0: m.class_.Dog) -> str
+
+        Invoked with: <m.class_.Pet object at 0>
+    """
+    )
+
+    with pytest.raises(TypeError) as excinfo:
+        m.Chimera("lion", "goat")
+    assert "No constructor defined!" in str(excinfo.value)
+
+
+def test_inheritance_init(msg):
+    # Single base
+    class Python(m.Pet):
+        def __init__(self):
+            pass
+
+    with pytest.raises(TypeError) as exc_info:
+        Python()
+    expected = "m.class_.Pet.__init__() must be called when overriding __init__"
+    assert msg(exc_info.value) == expected
+
+    # Multiple bases
+    class RabbitHamster(m.Rabbit, m.Hamster):
+        def __init__(self):
+            m.Rabbit.__init__(self, "RabbitHamster")
+
+    with pytest.raises(TypeError) as exc_info:
+        RabbitHamster()
+    expected = "m.class_.Hamster.__init__() must be called when overriding __init__"
+    assert msg(exc_info.value) == expected
+
+
+@pytest.mark.parametrize(
+    "mock_return_value", [None, (1, 2, 3), m.Pet("Polly", "parrot"), m.Dog("Molly")]
+)
+def test_mock_new(mock_return_value):
+    with mock.patch.object(
+        m.Pet, "__new__", return_value=mock_return_value
+    ) as mock_new:
+        obj = m.Pet("Noname", "Nospecies")
+    assert obj is mock_return_value
+    mock_new.assert_called_once_with(m.Pet, "Noname", "Nospecies")
+
+
+def test_automatic_upcasting():
+    assert type(m.return_class_1()).__name__ == "DerivedClass1"
+    assert type(m.return_class_2()).__name__ == "DerivedClass2"
+    assert type(m.return_none()).__name__ == "NoneType"
+    # Repeat these a few times in a random order to ensure no invalid caching is applied
+    assert type(m.return_class_n(1)).__name__ == "DerivedClass1"
+    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
+    assert type(m.return_class_n(0)).__name__ == "BaseClass"
+    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
+    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
+    assert type(m.return_class_n(0)).__name__ == "BaseClass"
+    assert type(m.return_class_n(1)).__name__ == "DerivedClass1"
+
+
+def test_isinstance():
+    objects = [(), {}, m.Pet("Polly", "parrot")] + [m.Dog("Molly")] * 4
+    expected = (True, True, True, True, True, False, False)
+    assert m.check_instances(objects) == expected
+
+
+def test_mismatched_holder():
+    import re
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m.mismatched_holder_1()
+    assert re.match(
+        'generic_type: type ".*MismatchDerived1" does not have a non-default '
+        'holder type while its base ".*MismatchBase1" does',
+        str(excinfo.value),
+    )
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m.mismatched_holder_2()
+    assert re.match(
+        'generic_type: type ".*MismatchDerived2" has a non-default holder type '
+        'while its base ".*MismatchBase2" does not',
+        str(excinfo.value),
+    )
+
+
+def test_override_static():
+    """#511: problem with inheritance + overwritten def_static"""
+    b = m.MyBase.make()
+    d1 = m.MyDerived.make2()
+    d2 = m.MyDerived.make()
+
+    assert isinstance(b, m.MyBase)
+    assert isinstance(d1, m.MyDerived)
+    assert isinstance(d2, m.MyDerived)
+
+
+def test_implicit_conversion_life_support():
+    """Ensure the lifetime of temporary objects created for implicit conversions"""
+    assert m.implicitly_convert_argument(UserType(5)) == 5
+    assert m.implicitly_convert_variable(UserType(5)) == 5
+
+    assert "outside a bound function" in m.implicitly_convert_variable_fail(UserType(5))
+
+
+def test_operator_new_delete(capture):
+    """Tests that class-specific operator new/delete functions are invoked"""
+
+    class SubAliased(m.AliasedHasOpNewDelSize):
+        pass
+
+    with capture:
+        a = m.HasOpNewDel()
+        b = m.HasOpNewDelSize()
+        d = m.HasOpNewDelBoth()
+    assert (
+        capture
+        == """
+        A new 8
+        B new 4
+        D new 32
+    """
+    )
+    sz_alias = str(m.AliasedHasOpNewDelSize.size_alias)
+    sz_noalias = str(m.AliasedHasOpNewDelSize.size_noalias)
+    with capture:
+        c = m.AliasedHasOpNewDelSize()
+        c2 = SubAliased()
+    assert capture == ("C new " + sz_noalias + "\n" + "C new " + sz_alias + "\n")
+
+    with capture:
+        del a
+        pytest.gc_collect()
+        del b
+        pytest.gc_collect()
+        del d
+        pytest.gc_collect()
+    assert (
+        capture
+        == """
+        A delete
+        B delete 4
+        D delete
+    """
+    )
+
+    with capture:
+        del c
+        pytest.gc_collect()
+        del c2
+        pytest.gc_collect()
+    assert capture == ("C delete " + sz_noalias + "\n" + "C delete " + sz_alias + "\n")
+
+
+def test_bind_protected_functions():
+    """Expose protected member functions to Python using a helper class"""
+    a = m.ProtectedA()
+    assert a.foo() == 42
+
+    b = m.ProtectedB()
+    assert b.foo() == 42
+    assert m.read_foo(b.void_foo()) == 42
+    assert m.pointers_equal(b.get_self(), b)
+
+    class C(m.ProtectedB):
+        def __init__(self):
+            m.ProtectedB.__init__(self)
+
+        def foo(self):
+            return 0
+
+    c = C()
+    assert c.foo() == 0
+
+
+def test_brace_initialization():
+    """Tests that simple POD classes can be constructed using C++11 brace initialization"""
+    a = m.BraceInitialization(123, "test")
+    assert a.field1 == 123
+    assert a.field2 == "test"
+
+    # Tests that a non-simple class doesn't get brace initialization (if the
+    # class defines an initializer_list constructor, in particular, it would
+    # win over the expected constructor).
+    b = m.NoBraceInitialization([123, 456])
+    assert b.vec == [123, 456]
+
+
+@pytest.mark.xfail("env.PYPY")
+def test_class_refcount():
+    """Instances must correctly increase/decrease the reference count of their types (#1029)"""
+    from sys import getrefcount
+
+    class PyDog(m.Dog):
+        pass
+
+    for cls in m.Dog, PyDog:
+        refcount_1 = getrefcount(cls)
+        molly = [cls("Molly") for _ in range(10)]
+        refcount_2 = getrefcount(cls)
+
+        del molly
+        pytest.gc_collect()
+        refcount_3 = getrefcount(cls)
+
+        assert refcount_1 == refcount_3
+        assert refcount_2 > refcount_1
+
+
+def test_reentrant_implicit_conversion_failure(msg):
+    # ensure that there is no runaway reentrant implicit conversion (#1035)
+    with pytest.raises(TypeError) as excinfo:
+        m.BogusImplicitConversion(0)
+    assert (
+        msg(excinfo.value)
+        == """
+        __init__(): incompatible constructor arguments. The following argument types are supported:
+            1. m.class_.BogusImplicitConversion(arg0: m.class_.BogusImplicitConversion)
+
+        Invoked with: 0
+    """
+    )
+
+
+def test_error_after_conversions():
+    with pytest.raises(TypeError) as exc_info:
+        m.test_error_after_conversions("hello")
+    assert str(exc_info.value).startswith(
+        "Unable to convert function return value to a Python type!"
+    )
+
+
+def test_aligned():
+    if hasattr(m, "Aligned"):
+        p = m.Aligned().ptr()
+        assert p % 1024 == 0
+
+
+# https://foss.heptapod.net/pypy/pypy/-/issues/2742
+@pytest.mark.xfail("env.PYPY")
+def test_final():
+    with pytest.raises(TypeError) as exc_info:
+
+        class PyFinalChild(m.IsFinal):
+            pass
+
+    assert str(exc_info.value).endswith("is not an acceptable base type")
+
+
+# https://foss.heptapod.net/pypy/pypy/-/issues/2742
+@pytest.mark.xfail("env.PYPY")
+def test_non_final_final():
+    with pytest.raises(TypeError) as exc_info:
+
+        class PyNonFinalFinalChild(m.IsNonFinalFinal):
+            pass
+
+    assert str(exc_info.value).endswith("is not an acceptable base type")
+
+
+# https://github.com/pybind/pybind11/issues/1878
+def test_exception_rvalue_abort():
+    with pytest.raises(RuntimeError):
+        m.PyPrintDestructor().throw_something()
+
+
+# https://github.com/pybind/pybind11/issues/1568
+def test_multiple_instances_with_same_pointer():
+    n = 100
+    instances = [m.SamePointer() for _ in range(n)]
+    for i in range(n):
+        # We need to reuse the same allocated memory for with a different type,
+        # to ensure the bug in `deregister_instance_impl` is detected. Otherwise
+        # `Py_TYPE(self) == Py_TYPE(it->second)` will still succeed, even though
+        # the `instance` is already deleted.
+        instances[i] = m.Empty()
+    # No assert: if this does not trigger the error
+    #   pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
+    # and just completes without crashing, we're good.
+
+
+# https://github.com/pybind/pybind11/issues/1624
+def test_base_and_derived_nested_scope():
+    assert issubclass(m.DerivedWithNested, m.BaseWithNested)
+    assert m.BaseWithNested.Nested != m.DerivedWithNested.Nested
+    assert m.BaseWithNested.Nested.get_name() == "BaseWithNested::Nested"
+    assert m.DerivedWithNested.Nested.get_name() == "DerivedWithNested::Nested"
+
+
+def test_register_duplicate_class():
+    import types
+
+    module_scope = types.ModuleType("module_scope")
+    with pytest.raises(RuntimeError) as exc_info:
+        m.register_duplicate_class_name(module_scope)
+    expected = (
+        'generic_type: cannot initialize type "Duplicate": '
+        "an object with that name is already defined"
+    )
+    assert str(exc_info.value) == expected
+    with pytest.raises(RuntimeError) as exc_info:
+        m.register_duplicate_class_type(module_scope)
+    expected = 'generic_type: type "YetAnotherDuplicate" is already registered!'
+    assert str(exc_info.value) == expected
+
+    class ClassScope:
+        pass
+
+    with pytest.raises(RuntimeError) as exc_info:
+        m.register_duplicate_nested_class_name(ClassScope)
+    expected = (
+        'generic_type: cannot initialize type "DuplicateNested": '
+        "an object with that name is already defined"
+    )
+    assert str(exc_info.value) == expected
+    with pytest.raises(RuntimeError) as exc_info:
+        m.register_duplicate_nested_class_type(ClassScope)
+    expected = 'generic_type: type "YetAnotherDuplicateNested" is already registered!'
+    assert str(exc_info.value) == expected
+
+
+def test_pr4220_tripped_over_this():
+    assert (
+        m.Empty0().get_msg()
+        == "This is really only meant to exercise successful compilation."
+    )

third_party/CityFlow/extern/pybind11/tests/test_const_name.cpp

@@ -1,55 +1,55 @@
-// Copyright (c) 2021 The Pybind Development Team.
-// All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#include "pybind11_tests.h"
-
-// IUT = Implementation Under Test
-#define CONST_NAME_TESTS(TEST_FUNC, IUT)                                                          \
-    std::string TEST_FUNC(int selector) {                                                         \
-        switch (selector) {                                                                       \
-            case 0:                                                                               \
-                return IUT("").text;                                                              \
-            case 1:                                                                               \
-                return IUT("A").text;                                                             \
-            case 2:                                                                               \
-                return IUT("Bd").text;                                                            \
-            case 3:                                                                               \
-                return IUT("Cef").text;                                                           \
-            case 4:                                                                               \
-                return IUT<int>().text; /*NOLINT(bugprone-macro-parentheses)*/                    \
-            case 5:                                                                               \
-                return IUT<std::string>().text; /*NOLINT(bugprone-macro-parentheses)*/            \
-            case 6:                                                                               \
-                return IUT<true>("T1", "T2").text; /*NOLINT(bugprone-macro-parentheses)*/         \
-            case 7:                                                                               \
-                return IUT<false>("U1", "U2").text; /*NOLINT(bugprone-macro-parentheses)*/        \
-            case 8:                                                                               \
-                /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                                    \
-                return IUT<true>(IUT("D1"), IUT("D2")).text;                                      \
-            case 9:                                                                               \
-                /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                                    \
-                return IUT<false>(IUT("E1"), IUT("E2")).text;                                     \
-            case 10:                                                                              \
-                return IUT("KeepAtEnd").text;                                                     \
-            default:                                                                              \
-                break;                                                                            \
-        }                                                                                         \
-        throw std::runtime_error("Invalid selector value.");                                      \
-    }
-
-CONST_NAME_TESTS(const_name_tests, py::detail::const_name)
-
-#ifdef PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY
-CONST_NAME_TESTS(underscore_tests, py::detail::_)
-#endif
-
-TEST_SUBMODULE(const_name, m) {
-    m.def("const_name_tests", const_name_tests);
-
-#if defined(PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY)
-    m.def("underscore_tests", underscore_tests);
-#else
-    m.attr("underscore_tests") = "PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY not defined.";
-#endif
-}
+// Copyright (c) 2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#include "pybind11_tests.h"
+
+// IUT = Implementation Under Test
+#define CONST_NAME_TESTS(TEST_FUNC, IUT)                                                          \
+    std::string TEST_FUNC(int selector) {                                                         \
+        switch (selector) {                                                                       \
+            case 0:                                                                               \
+                return IUT("").text;                                                              \
+            case 1:                                                                               \
+                return IUT("A").text;                                                             \
+            case 2:                                                                               \
+                return IUT("Bd").text;                                                            \
+            case 3:                                                                               \
+                return IUT("Cef").text;                                                           \
+            case 4:                                                                               \
+                return IUT<int>().text; /*NOLINT(bugprone-macro-parentheses)*/                    \
+            case 5:                                                                               \
+                return IUT<std::string>().text; /*NOLINT(bugprone-macro-parentheses)*/            \
+            case 6:                                                                               \
+                return IUT<true>("T1", "T2").text; /*NOLINT(bugprone-macro-parentheses)*/         \
+            case 7:                                                                               \
+                return IUT<false>("U1", "U2").text; /*NOLINT(bugprone-macro-parentheses)*/        \
+            case 8:                                                                               \
+                /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                                    \
+                return IUT<true>(IUT("D1"), IUT("D2")).text;                                      \
+            case 9:                                                                               \
+                /*NOLINTNEXTLINE(bugprone-macro-parentheses)*/                                    \
+                return IUT<false>(IUT("E1"), IUT("E2")).text;                                     \
+            case 10:                                                                              \
+                return IUT("KeepAtEnd").text;                                                     \
+            default:                                                                              \
+                break;                                                                            \
+        }                                                                                         \
+        throw std::runtime_error("Invalid selector value.");                                      \
+    }
+
+CONST_NAME_TESTS(const_name_tests, py::detail::const_name)
+
+#ifdef PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY
+CONST_NAME_TESTS(underscore_tests, py::detail::_)
+#endif
+
+TEST_SUBMODULE(const_name, m) {
+    m.def("const_name_tests", const_name_tests);
+
+#if defined(PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY)
+    m.def("underscore_tests", underscore_tests);
+#else
+    m.attr("underscore_tests") = "PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY not defined.";
+#endif
+}

third_party/CityFlow/extern/pybind11/tests/test_const_name.py

@@ -1,29 +1,29 @@
-import pytest
-
-from pybind11_tests import const_name as m
-
-
-@pytest.mark.parametrize("func", [m.const_name_tests, m.underscore_tests])
-@pytest.mark.parametrize(
-    ("selector", "expected"),
-    enumerate(
-        (
-            "",
-            "A",
-            "Bd",
-            "Cef",
-            "%",
-            "%",
-            "T1",
-            "U2",
-            "D1",
-            "E2",
-            "KeepAtEnd",
-        )
-    ),
-)
-def test_const_name(func, selector, expected):
-    if isinstance(func, str):
-        pytest.skip(func)
-    text = func(selector)
-    assert text == expected
+import pytest
+
+from pybind11_tests import const_name as m
+
+
+@pytest.mark.parametrize("func", [m.const_name_tests, m.underscore_tests])
+@pytest.mark.parametrize(
+    ("selector", "expected"),
+    enumerate(
+        (
+            "",
+            "A",
+            "Bd",
+            "Cef",
+            "%",
+            "%",
+            "T1",
+            "U2",
+            "D1",
+            "E2",
+            "KeepAtEnd",
+        )
+    ),
+)
+def test_const_name(func, selector, expected):
+    if isinstance(func, str):
+        pytest.skip(func)
+    text = func(selector)
+    assert text == expected

third_party/CityFlow/extern/pybind11/tests/test_constants_and_functions.cpp

@@ -1,158 +1,158 @@
-/*
-    tests/test_constants_and_functions.cpp -- global constants and functions, enumerations, raw
-    byte strings
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-enum MyEnum { EFirstEntry = 1, ESecondEntry };
-
-std::string test_function1() { return "test_function()"; }
-
-std::string test_function2(MyEnum k) { return "test_function(enum=" + std::to_string(k) + ")"; }
-
-std::string test_function3(int i) { return "test_function(" + std::to_string(i) + ")"; }
-
-py::str test_function4() { return "test_function()"; }
-py::str test_function4(char *) { return "test_function(char *)"; }
-py::str test_function4(int, float) { return "test_function(int, float)"; }
-py::str test_function4(float, int) { return "test_function(float, int)"; }
-
-py::bytes return_bytes() {
-    const char *data = "\x01\x00\x02\x00";
-    return std::string(data, 4);
-}
-
-std::string print_bytes(const py::bytes &bytes) {
-    std::string ret = "bytes[";
-    const auto value = static_cast<std::string>(bytes);
-    for (char c : value) {
-        ret += std::to_string(static_cast<int>(c)) + ' ';
-    }
-    ret.back() = ']';
-    return ret;
-}
-
-// Test that we properly handle C++17 exception specifiers (which are part of the function
-// signature in C++17).  These should all still work before C++17, but don't affect the function
-// signature.
-namespace test_exc_sp {
-// [workaround(intel)] Unable to use noexcept instead of noexcept(true)
-// Make the f1 test basically the same as the f2 test in C++17 mode for the Intel compiler as
-// it fails to compile with a plain noexcept (tested with icc (ICC) 2021.1 Beta 20200827).
-#if defined(__INTEL_COMPILER) && defined(PYBIND11_CPP17)
-int f1(int x) noexcept(true) { return x + 1; }
-#else
-int f1(int x) noexcept { return x + 1; }
-#endif
-int f2(int x) noexcept(true) { return x + 2; }
-int f3(int x) noexcept(false) { return x + 3; }
-PYBIND11_WARNING_PUSH
-PYBIND11_WARNING_DISABLE_GCC("-Wdeprecated")
-#if defined(__clang_major__) && __clang_major__ >= 5
-PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated-dynamic-exception-spec")
-#else
-PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated")
-#endif
-// NOLINTNEXTLINE(modernize-use-noexcept)
-int f4(int x) throw() { return x + 4; } // Deprecated equivalent to noexcept(true)
-PYBIND11_WARNING_POP
-struct C {
-    int m1(int x) noexcept { return x - 1; }
-    int m2(int x) const noexcept { return x - 2; }
-    int m3(int x) noexcept(true) { return x - 3; }
-    int m4(int x) const noexcept(true) { return x - 4; }
-    int m5(int x) noexcept(false) { return x - 5; }
-    int m6(int x) const noexcept(false) { return x - 6; }
-    PYBIND11_WARNING_PUSH
-    PYBIND11_WARNING_DISABLE_GCC("-Wdeprecated")
-    PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated")
-    // NOLINTNEXTLINE(modernize-use-noexcept)
-    int m7(int x) throw() { return x - 7; }
-    // NOLINTNEXTLINE(modernize-use-noexcept)
-    int m8(int x) const throw() { return x - 8; }
-    PYBIND11_WARNING_POP
-};
-} // namespace test_exc_sp
-
-TEST_SUBMODULE(constants_and_functions, m) {
-    // test_constants
-    m.attr("some_constant") = py::int_(14);
-
-    // test_function_overloading
-    m.def("test_function", &test_function1);
-    m.def("test_function", &test_function2);
-    m.def("test_function", &test_function3);
-
-#if defined(PYBIND11_OVERLOAD_CAST)
-    m.def("test_function", py::overload_cast<>(&test_function4));
-    m.def("test_function", py::overload_cast<char *>(&test_function4));
-    m.def("test_function", py::overload_cast<int, float>(&test_function4));
-    m.def("test_function", py::overload_cast<float, int>(&test_function4));
-#else
-    m.def("test_function", static_cast<py::str (*)()>(&test_function4));
-    m.def("test_function", static_cast<py::str (*)(char *)>(&test_function4));
-    m.def("test_function", static_cast<py::str (*)(int, float)>(&test_function4));
-    m.def("test_function", static_cast<py::str (*)(float, int)>(&test_function4));
-#endif
-
-    py::enum_<MyEnum>(m, "MyEnum")
-        .value("EFirstEntry", EFirstEntry)
-        .value("ESecondEntry", ESecondEntry)
-        .export_values();
-
-    // test_bytes
-    m.def("return_bytes", &return_bytes);
-    m.def("print_bytes", &print_bytes);
-
-    // test_exception_specifiers
-    using namespace test_exc_sp;
-    py::class_<C>(m, "C")
-        .def(py::init<>())
-        .def("m1", &C::m1)
-        .def("m2", &C::m2)
-        .def("m3", &C::m3)
-        .def("m4", &C::m4)
-        .def("m5", &C::m5)
-        .def("m6", &C::m6)
-        .def("m7", &C::m7)
-        .def("m8", &C::m8);
-    m.def("f1", f1);
-    m.def("f2", f2);
-
-    PYBIND11_WARNING_PUSH
-    PYBIND11_WARNING_DISABLE_INTEL(878) // incompatible exception specifications
-    m.def("f3", f3);
-    PYBIND11_WARNING_POP
-
-    m.def("f4", f4);
-
-    // test_function_record_leaks
-    m.def("register_large_capture_with_invalid_arguments", [](py::module_ m) {
-        // This should always be enough to trigger the alternative branch
-        // where `sizeof(capture) > sizeof(rec->data)`
-        uint64_t capture[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-#if defined(__GNUC__) && __GNUC__ == 4 // CentOS7
-        py::detail::silence_unused_warnings(capture);
-#endif
-        m.def(
-            "should_raise", [capture](int) { return capture[9] + 33; }, py::kw_only(), py::arg());
-    });
-    m.def("register_with_raising_repr", [](py::module_ m, const py::object &default_value) {
-        m.def(
-            "should_raise",
-            [](int, int, const py::object &) { return 42; },
-            "some docstring",
-            py::arg_v("x", 42),
-            py::arg_v("y", 42, "<the answer>"),
-            py::arg_v("z", default_value));
-    });
-
-    // test noexcept(true) lambda (#4565)
-    m.def("l1", []() noexcept(true) { return 0; });
-}
+/*
+    tests/test_constants_and_functions.cpp -- global constants and functions, enumerations, raw
+    byte strings
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "pybind11_tests.h"
+
+enum MyEnum { EFirstEntry = 1, ESecondEntry };
+
+std::string test_function1() { return "test_function()"; }
+
+std::string test_function2(MyEnum k) { return "test_function(enum=" + std::to_string(k) + ")"; }
+
+std::string test_function3(int i) { return "test_function(" + std::to_string(i) + ")"; }
+
+py::str test_function4() { return "test_function()"; }
+py::str test_function4(char *) { return "test_function(char *)"; }
+py::str test_function4(int, float) { return "test_function(int, float)"; }
+py::str test_function4(float, int) { return "test_function(float, int)"; }
+
+py::bytes return_bytes() {
+    const char *data = "\x01\x00\x02\x00";
+    return std::string(data, 4);
+}
+
+std::string print_bytes(const py::bytes &bytes) {
+    std::string ret = "bytes[";
+    const auto value = static_cast<std::string>(bytes);
+    for (char c : value) {
+        ret += std::to_string(static_cast<int>(c)) + ' ';
+    }
+    ret.back() = ']';
+    return ret;
+}
+
+// Test that we properly handle C++17 exception specifiers (which are part of the function
+// signature in C++17).  These should all still work before C++17, but don't affect the function
+// signature.
+namespace test_exc_sp {
+// [workaround(intel)] Unable to use noexcept instead of noexcept(true)
+// Make the f1 test basically the same as the f2 test in C++17 mode for the Intel compiler as
+// it fails to compile with a plain noexcept (tested with icc (ICC) 2021.1 Beta 20200827).
+#if defined(__INTEL_COMPILER) && defined(PYBIND11_CPP17)
+int f1(int x) noexcept(true) { return x + 1; }
+#else
+int f1(int x) noexcept { return x + 1; }
+#endif
+int f2(int x) noexcept(true) { return x + 2; }
+int f3(int x) noexcept(false) { return x + 3; }
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_GCC("-Wdeprecated")
+#if defined(__clang_major__) && __clang_major__ >= 5
+PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated-dynamic-exception-spec")
+#else
+PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated")
+#endif
+// NOLINTNEXTLINE(modernize-use-noexcept)
+int f4(int x) throw() { return x + 4; } // Deprecated equivalent to noexcept(true)
+PYBIND11_WARNING_POP
+struct C {
+    int m1(int x) noexcept { return x - 1; }
+    int m2(int x) const noexcept { return x - 2; }
+    int m3(int x) noexcept(true) { return x - 3; }
+    int m4(int x) const noexcept(true) { return x - 4; }
+    int m5(int x) noexcept(false) { return x - 5; }
+    int m6(int x) const noexcept(false) { return x - 6; }
+    PYBIND11_WARNING_PUSH
+    PYBIND11_WARNING_DISABLE_GCC("-Wdeprecated")
+    PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated")
+    // NOLINTNEXTLINE(modernize-use-noexcept)
+    int m7(int x) throw() { return x - 7; }
+    // NOLINTNEXTLINE(modernize-use-noexcept)
+    int m8(int x) const throw() { return x - 8; }
+    PYBIND11_WARNING_POP
+};
+} // namespace test_exc_sp
+
+TEST_SUBMODULE(constants_and_functions, m) {
+    // test_constants
+    m.attr("some_constant") = py::int_(14);
+
+    // test_function_overloading
+    m.def("test_function", &test_function1);
+    m.def("test_function", &test_function2);
+    m.def("test_function", &test_function3);
+
+#if defined(PYBIND11_OVERLOAD_CAST)
+    m.def("test_function", py::overload_cast<>(&test_function4));
+    m.def("test_function", py::overload_cast<char *>(&test_function4));
+    m.def("test_function", py::overload_cast<int, float>(&test_function4));
+    m.def("test_function", py::overload_cast<float, int>(&test_function4));
+#else
+    m.def("test_function", static_cast<py::str (*)()>(&test_function4));
+    m.def("test_function", static_cast<py::str (*)(char *)>(&test_function4));
+    m.def("test_function", static_cast<py::str (*)(int, float)>(&test_function4));
+    m.def("test_function", static_cast<py::str (*)(float, int)>(&test_function4));
+#endif
+
+    py::enum_<MyEnum>(m, "MyEnum")
+        .value("EFirstEntry", EFirstEntry)
+        .value("ESecondEntry", ESecondEntry)
+        .export_values();
+
+    // test_bytes
+    m.def("return_bytes", &return_bytes);
+    m.def("print_bytes", &print_bytes);
+
+    // test_exception_specifiers
+    using namespace test_exc_sp;
+    py::class_<C>(m, "C")
+        .def(py::init<>())
+        .def("m1", &C::m1)
+        .def("m2", &C::m2)
+        .def("m3", &C::m3)
+        .def("m4", &C::m4)
+        .def("m5", &C::m5)
+        .def("m6", &C::m6)
+        .def("m7", &C::m7)
+        .def("m8", &C::m8);
+    m.def("f1", f1);
+    m.def("f2", f2);
+
+    PYBIND11_WARNING_PUSH
+    PYBIND11_WARNING_DISABLE_INTEL(878) // incompatible exception specifications
+    m.def("f3", f3);
+    PYBIND11_WARNING_POP
+
+    m.def("f4", f4);
+
+    // test_function_record_leaks
+    m.def("register_large_capture_with_invalid_arguments", [](py::module_ m) {
+        // This should always be enough to trigger the alternative branch
+        // where `sizeof(capture) > sizeof(rec->data)`
+        uint64_t capture[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+#if defined(__GNUC__) && __GNUC__ == 4 // CentOS7
+        py::detail::silence_unused_warnings(capture);
+#endif
+        m.def(
+            "should_raise", [capture](int) { return capture[9] + 33; }, py::kw_only(), py::arg());
+    });
+    m.def("register_with_raising_repr", [](py::module_ m, const py::object &default_value) {
+        m.def(
+            "should_raise",
+            [](int, int, const py::object &) { return 42; },
+            "some docstring",
+            py::arg_v("x", 42),
+            py::arg_v("y", 42, "<the answer>"),
+            py::arg_v("z", default_value));
+    });
+
+    // test noexcept(true) lambda (#4565)
+    m.def("l1", []() noexcept(true) { return 0; });
+}

third_party/CityFlow/extern/pybind11/tests/test_constants_and_functions.py

@@ -1,56 +1,56 @@
-import pytest
-
-m = pytest.importorskip("pybind11_tests.constants_and_functions")
-
-
-def test_constants():
-    assert m.some_constant == 14
-
-
-def test_function_overloading():
-    assert m.test_function() == "test_function()"
-    assert m.test_function(7) == "test_function(7)"
-    assert m.test_function(m.MyEnum.EFirstEntry) == "test_function(enum=1)"
-    assert m.test_function(m.MyEnum.ESecondEntry) == "test_function(enum=2)"
-
-    assert m.test_function() == "test_function()"
-    assert m.test_function("abcd") == "test_function(char *)"
-    assert m.test_function(1, 1.0) == "test_function(int, float)"
-    assert m.test_function(1, 1.0) == "test_function(int, float)"
-    assert m.test_function(2.0, 2) == "test_function(float, int)"
-
-
-def test_bytes():
-    assert m.print_bytes(m.return_bytes()) == "bytes[1 0 2 0]"
-
-
-def test_exception_specifiers():
-    c = m.C()
-    assert c.m1(2) == 1
-    assert c.m2(3) == 1
-    assert c.m3(5) == 2
-    assert c.m4(7) == 3
-    assert c.m5(10) == 5
-    assert c.m6(14) == 8
-    assert c.m7(20) == 13
-    assert c.m8(29) == 21
-
-    assert m.f1(33) == 34
-    assert m.f2(53) == 55
-    assert m.f3(86) == 89
-    assert m.f4(140) == 144
-
-
-def test_function_record_leaks():
-    class RaisingRepr:
-        def __repr__(self):
-            raise RuntimeError("Surprise!")
-
-    with pytest.raises(RuntimeError):
-        m.register_large_capture_with_invalid_arguments(m)
-    with pytest.raises(RuntimeError):
-        m.register_with_raising_repr(m, RaisingRepr())
-
-
-def test_noexcept_lambda():
-    assert m.l1() == 0
+import pytest
+
+m = pytest.importorskip("pybind11_tests.constants_and_functions")
+
+
+def test_constants():
+    assert m.some_constant == 14
+
+
+def test_function_overloading():
+    assert m.test_function() == "test_function()"
+    assert m.test_function(7) == "test_function(7)"
+    assert m.test_function(m.MyEnum.EFirstEntry) == "test_function(enum=1)"
+    assert m.test_function(m.MyEnum.ESecondEntry) == "test_function(enum=2)"
+
+    assert m.test_function() == "test_function()"
+    assert m.test_function("abcd") == "test_function(char *)"
+    assert m.test_function(1, 1.0) == "test_function(int, float)"
+    assert m.test_function(1, 1.0) == "test_function(int, float)"
+    assert m.test_function(2.0, 2) == "test_function(float, int)"
+
+
+def test_bytes():
+    assert m.print_bytes(m.return_bytes()) == "bytes[1 0 2 0]"
+
+
+def test_exception_specifiers():
+    c = m.C()
+    assert c.m1(2) == 1
+    assert c.m2(3) == 1
+    assert c.m3(5) == 2
+    assert c.m4(7) == 3
+    assert c.m5(10) == 5
+    assert c.m6(14) == 8
+    assert c.m7(20) == 13
+    assert c.m8(29) == 21
+
+    assert m.f1(33) == 34
+    assert m.f2(53) == 55
+    assert m.f3(86) == 89
+    assert m.f4(140) == 144
+
+
+def test_function_record_leaks():
+    class RaisingRepr:
+        def __repr__(self):
+            raise RuntimeError("Surprise!")
+
+    with pytest.raises(RuntimeError):
+        m.register_large_capture_with_invalid_arguments(m)
+    with pytest.raises(RuntimeError):
+        m.register_with_raising_repr(m, RaisingRepr())
+
+
+def test_noexcept_lambda():
+    assert m.l1() == 0

third_party/CityFlow/extern/pybind11/tests/test_copy_move.cpp

@@ -1,533 +1,533 @@
-/*
-    tests/test_copy_move_policies.cpp -- 'copy' and 'move' return value policies
-                                         and related tests
-
-    Copyright (c) 2016 Ben North <ben@redfrontdoor.org>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/stl.h>
-
-#include "constructor_stats.h"
-#include "pybind11_tests.h"
-
-#include <type_traits>
-
-template <typename derived>
-struct empty {
-    static const derived &get_one() { return instance_; }
-    static derived instance_;
-};
-
-struct lacking_copy_ctor : public empty<lacking_copy_ctor> {
-    lacking_copy_ctor() = default;
-    lacking_copy_ctor(const lacking_copy_ctor &other) = delete;
-};
-
-template <>
-lacking_copy_ctor empty<lacking_copy_ctor>::instance_ = {};
-
-struct lacking_move_ctor : public empty<lacking_move_ctor> {
-    lacking_move_ctor() = default;
-    lacking_move_ctor(const lacking_move_ctor &other) = delete;
-    lacking_move_ctor(lacking_move_ctor &&other) = delete;
-};
-
-template <>
-lacking_move_ctor empty<lacking_move_ctor>::instance_ = {};
-
-/* Custom type caster move/copy test classes */
-class MoveOnlyInt {
-public:
-    MoveOnlyInt() { print_default_created(this); }
-    explicit MoveOnlyInt(int v) : value{v} { print_created(this, value); }
-    MoveOnlyInt(MoveOnlyInt &&m) noexcept {
-        print_move_created(this, m.value);
-        std::swap(value, m.value);
-    }
-    MoveOnlyInt &operator=(MoveOnlyInt &&m) noexcept {
-        print_move_assigned(this, m.value);
-        std::swap(value, m.value);
-        return *this;
-    }
-    MoveOnlyInt(const MoveOnlyInt &) = delete;
-    MoveOnlyInt &operator=(const MoveOnlyInt &) = delete;
-    ~MoveOnlyInt() { print_destroyed(this); }
-
-    int value;
-};
-class MoveOrCopyInt {
-public:
-    MoveOrCopyInt() { print_default_created(this); }
-    explicit MoveOrCopyInt(int v) : value{v} { print_created(this, value); }
-    MoveOrCopyInt(MoveOrCopyInt &&m) noexcept {
-        print_move_created(this, m.value);
-        std::swap(value, m.value);
-    }
-    MoveOrCopyInt &operator=(MoveOrCopyInt &&m) noexcept {
-        print_move_assigned(this, m.value);
-        std::swap(value, m.value);
-        return *this;
-    }
-    MoveOrCopyInt(const MoveOrCopyInt &c) {
-        print_copy_created(this, c.value);
-        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-        value = c.value;
-    }
-    MoveOrCopyInt &operator=(const MoveOrCopyInt &c) {
-        print_copy_assigned(this, c.value);
-        value = c.value;
-        return *this;
-    }
-    ~MoveOrCopyInt() { print_destroyed(this); }
-
-    int value;
-};
-class CopyOnlyInt {
-public:
-    CopyOnlyInt() { print_default_created(this); }
-    explicit CopyOnlyInt(int v) : value{v} { print_created(this, value); }
-    CopyOnlyInt(const CopyOnlyInt &c) {
-        print_copy_created(this, c.value);
-        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-        value = c.value;
-    }
-    CopyOnlyInt &operator=(const CopyOnlyInt &c) {
-        print_copy_assigned(this, c.value);
-        value = c.value;
-        return *this;
-    }
-    ~CopyOnlyInt() { print_destroyed(this); }
-
-    int value;
-};
-PYBIND11_NAMESPACE_BEGIN(pybind11)
-PYBIND11_NAMESPACE_BEGIN(detail)
-template <>
-struct type_caster<MoveOnlyInt> {
-    PYBIND11_TYPE_CASTER(MoveOnlyInt, const_name("MoveOnlyInt"));
-    bool load(handle src, bool) {
-        value = MoveOnlyInt(src.cast<int>());
-        return true;
-    }
-    static handle cast(const MoveOnlyInt &m, return_value_policy r, handle p) {
-        return pybind11::cast(m.value, r, p);
-    }
-};
-
-template <>
-struct type_caster<MoveOrCopyInt> {
-    PYBIND11_TYPE_CASTER(MoveOrCopyInt, const_name("MoveOrCopyInt"));
-    bool load(handle src, bool) {
-        value = MoveOrCopyInt(src.cast<int>());
-        return true;
-    }
-    static handle cast(const MoveOrCopyInt &m, return_value_policy r, handle p) {
-        return pybind11::cast(m.value, r, p);
-    }
-};
-
-template <>
-struct type_caster<CopyOnlyInt> {
-protected:
-    CopyOnlyInt value;
-
-public:
-    static constexpr auto name = const_name("CopyOnlyInt");
-    bool load(handle src, bool) {
-        value = CopyOnlyInt(src.cast<int>());
-        return true;
-    }
-    static handle cast(const CopyOnlyInt &m, return_value_policy r, handle p) {
-        return pybind11::cast(m.value, r, p);
-    }
-    static handle cast(const CopyOnlyInt *src, return_value_policy policy, handle parent) {
-        if (!src) {
-            return none().release();
-        }
-        return cast(*src, policy, parent);
-    }
-    explicit operator CopyOnlyInt *() { return &value; }
-    explicit operator CopyOnlyInt &() { return value; }
-    template <typename T>
-    using cast_op_type = pybind11::detail::cast_op_type<T>;
-};
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(pybind11)
-
-TEST_SUBMODULE(copy_move_policies, m) {
-    // test_lacking_copy_ctor
-    py::class_<lacking_copy_ctor>(m, "lacking_copy_ctor")
-        .def_static("get_one", &lacking_copy_ctor::get_one, py::return_value_policy::copy);
-    // test_lacking_move_ctor
-    py::class_<lacking_move_ctor>(m, "lacking_move_ctor")
-        .def_static("get_one", &lacking_move_ctor::get_one, py::return_value_policy::move);
-
-    // test_move_and_copy_casts
-    // NOLINTNEXTLINE(performance-unnecessary-value-param)
-    m.def("move_and_copy_casts", [](const py::object &o) {
-        int r = 0;
-        r += py::cast<MoveOrCopyInt>(o).value; /* moves */
-        r += py::cast<MoveOnlyInt>(o).value;   /* moves */
-        r += py::cast<CopyOnlyInt>(o).value;   /* copies */
-        auto m1(py::cast<MoveOrCopyInt>(o));   /* moves */
-        auto m2(py::cast<MoveOnlyInt>(o));     /* moves */
-        auto m3(py::cast<CopyOnlyInt>(o));     /* copies */
-        r += m1.value + m2.value + m3.value;
-
-        return r;
-    });
-
-    // test_move_and_copy_loads
-    m.def("move_only", [](MoveOnlyInt m) { return m.value; });
-    // Changing this breaks the existing test: needs careful review.
-    // NOLINTNEXTLINE(performance-unnecessary-value-param)
-    m.def("move_or_copy", [](MoveOrCopyInt m) { return m.value; });
-    // Changing this breaks the existing test: needs careful review.
-    // NOLINTNEXTLINE(performance-unnecessary-value-param)
-    m.def("copy_only", [](CopyOnlyInt m) { return m.value; });
-    m.def("move_pair",
-          [](std::pair<MoveOnlyInt, MoveOrCopyInt> p) { return p.first.value + p.second.value; });
-    m.def("move_tuple", [](std::tuple<MoveOnlyInt, MoveOrCopyInt, MoveOnlyInt> t) {
-        return std::get<0>(t).value + std::get<1>(t).value + std::get<2>(t).value;
-    });
-    m.def("copy_tuple", [](std::tuple<CopyOnlyInt, CopyOnlyInt> t) {
-        return std::get<0>(t).value + std::get<1>(t).value;
-    });
-    m.def("move_copy_nested",
-          [](std::pair<MoveOnlyInt,
-                       std::pair<std::tuple<MoveOrCopyInt, CopyOnlyInt, std::tuple<MoveOnlyInt>>,
-                                 MoveOrCopyInt>> x) {
-              return x.first.value + std::get<0>(x.second.first).value
-                     + std::get<1>(x.second.first).value
-                     + std::get<0>(std::get<2>(x.second.first)).value + x.second.second.value;
-          });
-    m.def("move_and_copy_cstats", []() {
-        ConstructorStats::gc();
-        // Reset counts to 0 so that previous tests don't affect later ones:
-        auto &mc = ConstructorStats::get<MoveOrCopyInt>();
-        mc.move_assignments = mc.move_constructions = mc.copy_assignments = mc.copy_constructions
-            = 0;
-        auto &mo = ConstructorStats::get<MoveOnlyInt>();
-        mo.move_assignments = mo.move_constructions = mo.copy_assignments = mo.copy_constructions
-            = 0;
-        auto &co = ConstructorStats::get<CopyOnlyInt>();
-        co.move_assignments = co.move_constructions = co.copy_assignments = co.copy_constructions
-            = 0;
-        py::dict d;
-        d["MoveOrCopyInt"] = py::cast(mc, py::return_value_policy::reference);
-        d["MoveOnlyInt"] = py::cast(mo, py::return_value_policy::reference);
-        d["CopyOnlyInt"] = py::cast(co, py::return_value_policy::reference);
-        return d;
-    });
-#ifdef PYBIND11_HAS_OPTIONAL
-    // test_move_and_copy_load_optional
-    m.attr("has_optional") = true;
-    m.def("move_optional", [](std::optional<MoveOnlyInt> o) { return o->value; });
-    m.def("move_or_copy_optional", [](std::optional<MoveOrCopyInt> o) { return o->value; });
-    m.def("copy_optional", [](std::optional<CopyOnlyInt> o) { return o->value; });
-    m.def("move_optional_tuple",
-          [](std::optional<std::tuple<MoveOrCopyInt, MoveOnlyInt, CopyOnlyInt>> x) {
-              return std::get<0>(*x).value + std::get<1>(*x).value + std::get<2>(*x).value;
-          });
-#else
-    m.attr("has_optional") = false;
-#endif
-
-    // #70 compilation issue if operator new is not public - simple body added
-    // but not needed on most compilers; MSVC and nvcc don't like a local
-    // struct not having a method defined when declared, since it can not be
-    // added later.
-    struct PrivateOpNew {
-        int value = 1;
-
-    private:
-        void *operator new(size_t bytes) {
-            void *ptr = std::malloc(bytes);
-            if (ptr) {
-                return ptr;
-            }
-            throw std::bad_alloc{};
-        }
-    };
-    py::class_<PrivateOpNew>(m, "PrivateOpNew").def_readonly("value", &PrivateOpNew::value);
-    m.def("private_op_new_value", []() { return PrivateOpNew(); });
-    m.def(
-        "private_op_new_reference",
-        []() -> const PrivateOpNew & {
-            static PrivateOpNew x{};
-            return x;
-        },
-        py::return_value_policy::reference);
-
-    // test_move_fallback
-    // #389: rvp::move should fall-through to copy on non-movable objects
-    struct MoveIssue1 {
-        int v;
-        explicit MoveIssue1(int v) : v{v} {}
-        MoveIssue1(const MoveIssue1 &c) = default;
-        MoveIssue1(MoveIssue1 &&) = delete;
-    };
-    py::class_<MoveIssue1>(m, "MoveIssue1")
-        .def(py::init<int>())
-        .def_readwrite("value", &MoveIssue1::v);
-
-    struct MoveIssue2 {
-        int v;
-        explicit MoveIssue2(int v) : v{v} {}
-        MoveIssue2(MoveIssue2 &&) = default;
-    };
-    py::class_<MoveIssue2>(m, "MoveIssue2")
-        .def(py::init<int>())
-        .def_readwrite("value", &MoveIssue2::v);
-
-    // #2742: Don't expect ownership of raw pointer to `new`ed object to be transferred with
-    // `py::return_value_policy::move`
-    m.def(
-        "get_moveissue1",
-        [](int i) { return std::unique_ptr<MoveIssue1>(new MoveIssue1(i)); },
-        py::return_value_policy::move);
-    m.def(
-        "get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
-
-    // Make sure that cast from pytype rvalue to other pytype works
-    m.def("get_pytype_rvalue_castissue", [](double i) { return py::float_(i).cast<py::int_>(); });
-}
-
-/*
- * Rest of the file:
- * static_assert based tests for pybind11 adaptations of
- * std::is_move_constructible, std::is_copy_constructible and
- * std::is_copy_assignable (no adaptation of std::is_move_assignable).
- * Difference between pybind11 and std traits: pybind11 traits will also check
- * the contained value_types.
- */
-
-struct NotMovable {
-    NotMovable() = default;
-    NotMovable(NotMovable const &) = default;
-    NotMovable(NotMovable &&) = delete;
-    NotMovable &operator=(NotMovable const &) = default;
-    NotMovable &operator=(NotMovable &&) = delete;
-};
-static_assert(!std::is_move_constructible<NotMovable>::value,
-              "!std::is_move_constructible<NotMovable>::value");
-static_assert(std::is_copy_constructible<NotMovable>::value,
-              "std::is_copy_constructible<NotMovable>::value");
-static_assert(!pybind11::detail::is_move_constructible<NotMovable>::value,
-              "!pybind11::detail::is_move_constructible<NotMovable>::value");
-static_assert(pybind11::detail::is_copy_constructible<NotMovable>::value,
-              "pybind11::detail::is_copy_constructible<NotMovable>::value");
-static_assert(!std::is_move_assignable<NotMovable>::value,
-              "!std::is_move_assignable<NotMovable>::value");
-static_assert(std::is_copy_assignable<NotMovable>::value,
-              "std::is_copy_assignable<NotMovable>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotMovable>::value,
-//               "!pybind11::detail::is_move_assignable<NotMovable>::value");
-static_assert(pybind11::detail::is_copy_assignable<NotMovable>::value,
-              "pybind11::detail::is_copy_assignable<NotMovable>::value");
-
-struct NotCopyable {
-    NotCopyable() = default;
-    NotCopyable(NotCopyable const &) = delete;
-    NotCopyable(NotCopyable &&) = default;
-    NotCopyable &operator=(NotCopyable const &) = delete;
-    NotCopyable &operator=(NotCopyable &&) = default;
-};
-static_assert(std::is_move_constructible<NotCopyable>::value,
-              "std::is_move_constructible<NotCopyable>::value");
-static_assert(!std::is_copy_constructible<NotCopyable>::value,
-              "!std::is_copy_constructible<NotCopyable>::value");
-static_assert(pybind11::detail::is_move_constructible<NotCopyable>::value,
-              "pybind11::detail::is_move_constructible<NotCopyable>::value");
-static_assert(!pybind11::detail::is_copy_constructible<NotCopyable>::value,
-              "!pybind11::detail::is_copy_constructible<NotCopyable>::value");
-static_assert(std::is_move_assignable<NotCopyable>::value,
-              "std::is_move_assignable<NotCopyable>::value");
-static_assert(!std::is_copy_assignable<NotCopyable>::value,
-              "!std::is_copy_assignable<NotCopyable>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotCopyable>::value,
-//               "!pybind11::detail::is_move_assignable<NotCopyable>::value");
-static_assert(!pybind11::detail::is_copy_assignable<NotCopyable>::value,
-              "!pybind11::detail::is_copy_assignable<NotCopyable>::value");
-
-struct NotCopyableNotMovable {
-    NotCopyableNotMovable() = default;
-    NotCopyableNotMovable(NotCopyableNotMovable const &) = delete;
-    NotCopyableNotMovable(NotCopyableNotMovable &&) = delete;
-    NotCopyableNotMovable &operator=(NotCopyableNotMovable const &) = delete;
-    NotCopyableNotMovable &operator=(NotCopyableNotMovable &&) = delete;
-};
-static_assert(!std::is_move_constructible<NotCopyableNotMovable>::value,
-              "!std::is_move_constructible<NotCopyableNotMovable>::value");
-static_assert(!std::is_copy_constructible<NotCopyableNotMovable>::value,
-              "!std::is_copy_constructible<NotCopyableNotMovable>::value");
-static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value,
-              "!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value");
-static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value,
-              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value");
-static_assert(!std::is_move_assignable<NotCopyableNotMovable>::value,
-              "!std::is_move_assignable<NotCopyableNotMovable>::value");
-static_assert(!std::is_copy_assignable<NotCopyableNotMovable>::value,
-              "!std::is_copy_assignable<NotCopyableNotMovable>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value,
-//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value");
-static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value,
-              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value");
-
-struct NotMovableVector : std::vector<NotMovable> {};
-static_assert(std::is_move_constructible<NotMovableVector>::value,
-              "std::is_move_constructible<NotMovableVector>::value");
-static_assert(std::is_copy_constructible<NotMovableVector>::value,
-              "std::is_copy_constructible<NotMovableVector>::value");
-static_assert(!pybind11::detail::is_move_constructible<NotMovableVector>::value,
-              "!pybind11::detail::is_move_constructible<NotMovableVector>::value");
-static_assert(pybind11::detail::is_copy_constructible<NotMovableVector>::value,
-              "pybind11::detail::is_copy_constructible<NotMovableVector>::value");
-static_assert(std::is_move_assignable<NotMovableVector>::value,
-              "std::is_move_assignable<NotMovableVector>::value");
-static_assert(std::is_copy_assignable<NotMovableVector>::value,
-              "std::is_copy_assignable<NotMovableVector>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotMovableVector>::value,
-//               "!pybind11::detail::is_move_assignable<NotMovableVector>::value");
-static_assert(pybind11::detail::is_copy_assignable<NotMovableVector>::value,
-              "pybind11::detail::is_copy_assignable<NotMovableVector>::value");
-
-struct NotCopyableVector : std::vector<NotCopyable> {};
-static_assert(std::is_move_constructible<NotCopyableVector>::value,
-              "std::is_move_constructible<NotCopyableVector>::value");
-static_assert(std::is_copy_constructible<NotCopyableVector>::value,
-              "std::is_copy_constructible<NotCopyableVector>::value");
-static_assert(pybind11::detail::is_move_constructible<NotCopyableVector>::value,
-              "pybind11::detail::is_move_constructible<NotCopyableVector>::value");
-static_assert(!pybind11::detail::is_copy_constructible<NotCopyableVector>::value,
-              "!pybind11::detail::is_copy_constructible<NotCopyableVector>::value");
-static_assert(std::is_move_assignable<NotCopyableVector>::value,
-              "std::is_move_assignable<NotCopyableVector>::value");
-static_assert(std::is_copy_assignable<NotCopyableVector>::value,
-              "std::is_copy_assignable<NotCopyableVector>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotCopyableVector>::value,
-//               "!pybind11::detail::is_move_assignable<NotCopyableVector>::value");
-static_assert(!pybind11::detail::is_copy_assignable<NotCopyableVector>::value,
-              "!pybind11::detail::is_copy_assignable<NotCopyableVector>::value");
-
-struct NotCopyableNotMovableVector : std::vector<NotCopyableNotMovable> {};
-static_assert(std::is_move_constructible<NotCopyableNotMovableVector>::value,
-              "std::is_move_constructible<NotCopyableNotMovableVector>::value");
-static_assert(std::is_copy_constructible<NotCopyableNotMovableVector>::value,
-              "std::is_copy_constructible<NotCopyableNotMovableVector>::value");
-static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value,
-              "!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value");
-static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value,
-              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value");
-static_assert(std::is_move_assignable<NotCopyableNotMovableVector>::value,
-              "std::is_move_assignable<NotCopyableNotMovableVector>::value");
-static_assert(std::is_copy_assignable<NotCopyableNotMovableVector>::value,
-              "std::is_copy_assignable<NotCopyableNotMovableVector>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value,
-//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value");
-static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value,
-              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value");
-
-struct NotMovableMap : std::map<int, NotMovable> {};
-static_assert(std::is_move_constructible<NotMovableMap>::value,
-              "std::is_move_constructible<NotMovableMap>::value");
-static_assert(std::is_copy_constructible<NotMovableMap>::value,
-              "std::is_copy_constructible<NotMovableMap>::value");
-static_assert(!pybind11::detail::is_move_constructible<NotMovableMap>::value,
-              "!pybind11::detail::is_move_constructible<NotMovableMap>::value");
-static_assert(pybind11::detail::is_copy_constructible<NotMovableMap>::value,
-              "pybind11::detail::is_copy_constructible<NotMovableMap>::value");
-static_assert(std::is_move_assignable<NotMovableMap>::value,
-              "std::is_move_assignable<NotMovableMap>::value");
-static_assert(std::is_copy_assignable<NotMovableMap>::value,
-              "std::is_copy_assignable<NotMovableMap>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotMovableMap>::value,
-//               "!pybind11::detail::is_move_assignable<NotMovableMap>::value");
-static_assert(pybind11::detail::is_copy_assignable<NotMovableMap>::value,
-              "pybind11::detail::is_copy_assignable<NotMovableMap>::value");
-
-struct NotCopyableMap : std::map<int, NotCopyable> {};
-static_assert(std::is_move_constructible<NotCopyableMap>::value,
-              "std::is_move_constructible<NotCopyableMap>::value");
-static_assert(std::is_copy_constructible<NotCopyableMap>::value,
-              "std::is_copy_constructible<NotCopyableMap>::value");
-static_assert(pybind11::detail::is_move_constructible<NotCopyableMap>::value,
-              "pybind11::detail::is_move_constructible<NotCopyableMap>::value");
-static_assert(!pybind11::detail::is_copy_constructible<NotCopyableMap>::value,
-              "!pybind11::detail::is_copy_constructible<NotCopyableMap>::value");
-static_assert(std::is_move_assignable<NotCopyableMap>::value,
-              "std::is_move_assignable<NotCopyableMap>::value");
-static_assert(std::is_copy_assignable<NotCopyableMap>::value,
-              "std::is_copy_assignable<NotCopyableMap>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotCopyableMap>::value,
-//               "!pybind11::detail::is_move_assignable<NotCopyableMap>::value");
-static_assert(!pybind11::detail::is_copy_assignable<NotCopyableMap>::value,
-              "!pybind11::detail::is_copy_assignable<NotCopyableMap>::value");
-
-struct NotCopyableNotMovableMap : std::map<int, NotCopyableNotMovable> {};
-static_assert(std::is_move_constructible<NotCopyableNotMovableMap>::value,
-              "std::is_move_constructible<NotCopyableNotMovableMap>::value");
-static_assert(std::is_copy_constructible<NotCopyableNotMovableMap>::value,
-              "std::is_copy_constructible<NotCopyableNotMovableMap>::value");
-static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value,
-              "!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value");
-static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value,
-              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value");
-static_assert(std::is_move_assignable<NotCopyableNotMovableMap>::value,
-              "std::is_move_assignable<NotCopyableNotMovableMap>::value");
-static_assert(std::is_copy_assignable<NotCopyableNotMovableMap>::value,
-              "std::is_copy_assignable<NotCopyableNotMovableMap>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value,
-//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value");
-static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value,
-              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value");
-
-struct RecursiveVector : std::vector<RecursiveVector> {};
-static_assert(std::is_move_constructible<RecursiveVector>::value,
-              "std::is_move_constructible<RecursiveVector>::value");
-static_assert(std::is_copy_constructible<RecursiveVector>::value,
-              "std::is_copy_constructible<RecursiveVector>::value");
-static_assert(pybind11::detail::is_move_constructible<RecursiveVector>::value,
-              "pybind11::detail::is_move_constructible<RecursiveVector>::value");
-static_assert(pybind11::detail::is_copy_constructible<RecursiveVector>::value,
-              "pybind11::detail::is_copy_constructible<RecursiveVector>::value");
-static_assert(std::is_move_assignable<RecursiveVector>::value,
-              "std::is_move_assignable<RecursiveVector>::value");
-static_assert(std::is_copy_assignable<RecursiveVector>::value,
-              "std::is_copy_assignable<RecursiveVector>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<RecursiveVector>::value,
-//               "!pybind11::detail::is_move_assignable<RecursiveVector>::value");
-static_assert(pybind11::detail::is_copy_assignable<RecursiveVector>::value,
-              "pybind11::detail::is_copy_assignable<RecursiveVector>::value");
-
-struct RecursiveMap : std::map<int, RecursiveMap> {};
-static_assert(std::is_move_constructible<RecursiveMap>::value,
-              "std::is_move_constructible<RecursiveMap>::value");
-static_assert(std::is_copy_constructible<RecursiveMap>::value,
-              "std::is_copy_constructible<RecursiveMap>::value");
-static_assert(pybind11::detail::is_move_constructible<RecursiveMap>::value,
-              "pybind11::detail::is_move_constructible<RecursiveMap>::value");
-static_assert(pybind11::detail::is_copy_constructible<RecursiveMap>::value,
-              "pybind11::detail::is_copy_constructible<RecursiveMap>::value");
-static_assert(std::is_move_assignable<RecursiveMap>::value,
-              "std::is_move_assignable<RecursiveMap>::value");
-static_assert(std::is_copy_assignable<RecursiveMap>::value,
-              "std::is_copy_assignable<RecursiveMap>::value");
-// pybind11 does not have this
-// static_assert(!pybind11::detail::is_move_assignable<RecursiveMap>::value,
-//               "!pybind11::detail::is_move_assignable<RecursiveMap>::value");
-static_assert(pybind11::detail::is_copy_assignable<RecursiveMap>::value,
-              "pybind11::detail::is_copy_assignable<RecursiveMap>::value");
+/*
+    tests/test_copy_move_policies.cpp -- 'copy' and 'move' return value policies
+                                         and related tests
+
+    Copyright (c) 2016 Ben North <ben@redfrontdoor.org>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/stl.h>
+
+#include "constructor_stats.h"
+#include "pybind11_tests.h"
+
+#include <type_traits>
+
+template <typename derived>
+struct empty {
+    static const derived &get_one() { return instance_; }
+    static derived instance_;
+};
+
+struct lacking_copy_ctor : public empty<lacking_copy_ctor> {
+    lacking_copy_ctor() = default;
+    lacking_copy_ctor(const lacking_copy_ctor &other) = delete;
+};
+
+template <>
+lacking_copy_ctor empty<lacking_copy_ctor>::instance_ = {};
+
+struct lacking_move_ctor : public empty<lacking_move_ctor> {
+    lacking_move_ctor() = default;
+    lacking_move_ctor(const lacking_move_ctor &other) = delete;
+    lacking_move_ctor(lacking_move_ctor &&other) = delete;
+};
+
+template <>
+lacking_move_ctor empty<lacking_move_ctor>::instance_ = {};
+
+/* Custom type caster move/copy test classes */
+class MoveOnlyInt {
+public:
+    MoveOnlyInt() { print_default_created(this); }
+    explicit MoveOnlyInt(int v) : value{v} { print_created(this, value); }
+    MoveOnlyInt(MoveOnlyInt &&m) noexcept {
+        print_move_created(this, m.value);
+        std::swap(value, m.value);
+    }
+    MoveOnlyInt &operator=(MoveOnlyInt &&m) noexcept {
+        print_move_assigned(this, m.value);
+        std::swap(value, m.value);
+        return *this;
+    }
+    MoveOnlyInt(const MoveOnlyInt &) = delete;
+    MoveOnlyInt &operator=(const MoveOnlyInt &) = delete;
+    ~MoveOnlyInt() { print_destroyed(this); }
+
+    int value;
+};
+class MoveOrCopyInt {
+public:
+    MoveOrCopyInt() { print_default_created(this); }
+    explicit MoveOrCopyInt(int v) : value{v} { print_created(this, value); }
+    MoveOrCopyInt(MoveOrCopyInt &&m) noexcept {
+        print_move_created(this, m.value);
+        std::swap(value, m.value);
+    }
+    MoveOrCopyInt &operator=(MoveOrCopyInt &&m) noexcept {
+        print_move_assigned(this, m.value);
+        std::swap(value, m.value);
+        return *this;
+    }
+    MoveOrCopyInt(const MoveOrCopyInt &c) {
+        print_copy_created(this, c.value);
+        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+        value = c.value;
+    }
+    MoveOrCopyInt &operator=(const MoveOrCopyInt &c) {
+        print_copy_assigned(this, c.value);
+        value = c.value;
+        return *this;
+    }
+    ~MoveOrCopyInt() { print_destroyed(this); }
+
+    int value;
+};
+class CopyOnlyInt {
+public:
+    CopyOnlyInt() { print_default_created(this); }
+    explicit CopyOnlyInt(int v) : value{v} { print_created(this, value); }
+    CopyOnlyInt(const CopyOnlyInt &c) {
+        print_copy_created(this, c.value);
+        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+        value = c.value;
+    }
+    CopyOnlyInt &operator=(const CopyOnlyInt &c) {
+        print_copy_assigned(this, c.value);
+        value = c.value;
+        return *this;
+    }
+    ~CopyOnlyInt() { print_destroyed(this); }
+
+    int value;
+};
+PYBIND11_NAMESPACE_BEGIN(pybind11)
+PYBIND11_NAMESPACE_BEGIN(detail)
+template <>
+struct type_caster<MoveOnlyInt> {
+    PYBIND11_TYPE_CASTER(MoveOnlyInt, const_name("MoveOnlyInt"));
+    bool load(handle src, bool) {
+        value = MoveOnlyInt(src.cast<int>());
+        return true;
+    }
+    static handle cast(const MoveOnlyInt &m, return_value_policy r, handle p) {
+        return pybind11::cast(m.value, r, p);
+    }
+};
+
+template <>
+struct type_caster<MoveOrCopyInt> {
+    PYBIND11_TYPE_CASTER(MoveOrCopyInt, const_name("MoveOrCopyInt"));
+    bool load(handle src, bool) {
+        value = MoveOrCopyInt(src.cast<int>());
+        return true;
+    }
+    static handle cast(const MoveOrCopyInt &m, return_value_policy r, handle p) {
+        return pybind11::cast(m.value, r, p);
+    }
+};
+
+template <>
+struct type_caster<CopyOnlyInt> {
+protected:
+    CopyOnlyInt value;
+
+public:
+    static constexpr auto name = const_name("CopyOnlyInt");
+    bool load(handle src, bool) {
+        value = CopyOnlyInt(src.cast<int>());
+        return true;
+    }
+    static handle cast(const CopyOnlyInt &m, return_value_policy r, handle p) {
+        return pybind11::cast(m.value, r, p);
+    }
+    static handle cast(const CopyOnlyInt *src, return_value_policy policy, handle parent) {
+        if (!src) {
+            return none().release();
+        }
+        return cast(*src, policy, parent);
+    }
+    explicit operator CopyOnlyInt *() { return &value; }
+    explicit operator CopyOnlyInt &() { return value; }
+    template <typename T>
+    using cast_op_type = pybind11::detail::cast_op_type<T>;
+};
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(pybind11)
+
+TEST_SUBMODULE(copy_move_policies, m) {
+    // test_lacking_copy_ctor
+    py::class_<lacking_copy_ctor>(m, "lacking_copy_ctor")
+        .def_static("get_one", &lacking_copy_ctor::get_one, py::return_value_policy::copy);
+    // test_lacking_move_ctor
+    py::class_<lacking_move_ctor>(m, "lacking_move_ctor")
+        .def_static("get_one", &lacking_move_ctor::get_one, py::return_value_policy::move);
+
+    // test_move_and_copy_casts
+    // NOLINTNEXTLINE(performance-unnecessary-value-param)
+    m.def("move_and_copy_casts", [](const py::object &o) {
+        int r = 0;
+        r += py::cast<MoveOrCopyInt>(o).value; /* moves */
+        r += py::cast<MoveOnlyInt>(o).value;   /* moves */
+        r += py::cast<CopyOnlyInt>(o).value;   /* copies */
+        auto m1(py::cast<MoveOrCopyInt>(o));   /* moves */
+        auto m2(py::cast<MoveOnlyInt>(o));     /* moves */
+        auto m3(py::cast<CopyOnlyInt>(o));     /* copies */
+        r += m1.value + m2.value + m3.value;
+
+        return r;
+    });
+
+    // test_move_and_copy_loads
+    m.def("move_only", [](MoveOnlyInt m) { return m.value; });
+    // Changing this breaks the existing test: needs careful review.
+    // NOLINTNEXTLINE(performance-unnecessary-value-param)
+    m.def("move_or_copy", [](MoveOrCopyInt m) { return m.value; });
+    // Changing this breaks the existing test: needs careful review.
+    // NOLINTNEXTLINE(performance-unnecessary-value-param)
+    m.def("copy_only", [](CopyOnlyInt m) { return m.value; });
+    m.def("move_pair",
+          [](std::pair<MoveOnlyInt, MoveOrCopyInt> p) { return p.first.value + p.second.value; });
+    m.def("move_tuple", [](std::tuple<MoveOnlyInt, MoveOrCopyInt, MoveOnlyInt> t) {
+        return std::get<0>(t).value + std::get<1>(t).value + std::get<2>(t).value;
+    });
+    m.def("copy_tuple", [](std::tuple<CopyOnlyInt, CopyOnlyInt> t) {
+        return std::get<0>(t).value + std::get<1>(t).value;
+    });
+    m.def("move_copy_nested",
+          [](std::pair<MoveOnlyInt,
+                       std::pair<std::tuple<MoveOrCopyInt, CopyOnlyInt, std::tuple<MoveOnlyInt>>,
+                                 MoveOrCopyInt>> x) {
+              return x.first.value + std::get<0>(x.second.first).value
+                     + std::get<1>(x.second.first).value
+                     + std::get<0>(std::get<2>(x.second.first)).value + x.second.second.value;
+          });
+    m.def("move_and_copy_cstats", []() {
+        ConstructorStats::gc();
+        // Reset counts to 0 so that previous tests don't affect later ones:
+        auto &mc = ConstructorStats::get<MoveOrCopyInt>();
+        mc.move_assignments = mc.move_constructions = mc.copy_assignments = mc.copy_constructions
+            = 0;
+        auto &mo = ConstructorStats::get<MoveOnlyInt>();
+        mo.move_assignments = mo.move_constructions = mo.copy_assignments = mo.copy_constructions
+            = 0;
+        auto &co = ConstructorStats::get<CopyOnlyInt>();
+        co.move_assignments = co.move_constructions = co.copy_assignments = co.copy_constructions
+            = 0;
+        py::dict d;
+        d["MoveOrCopyInt"] = py::cast(mc, py::return_value_policy::reference);
+        d["MoveOnlyInt"] = py::cast(mo, py::return_value_policy::reference);
+        d["CopyOnlyInt"] = py::cast(co, py::return_value_policy::reference);
+        return d;
+    });
+#ifdef PYBIND11_HAS_OPTIONAL
+    // test_move_and_copy_load_optional
+    m.attr("has_optional") = true;
+    m.def("move_optional", [](std::optional<MoveOnlyInt> o) { return o->value; });
+    m.def("move_or_copy_optional", [](std::optional<MoveOrCopyInt> o) { return o->value; });
+    m.def("copy_optional", [](std::optional<CopyOnlyInt> o) { return o->value; });
+    m.def("move_optional_tuple",
+          [](std::optional<std::tuple<MoveOrCopyInt, MoveOnlyInt, CopyOnlyInt>> x) {
+              return std::get<0>(*x).value + std::get<1>(*x).value + std::get<2>(*x).value;
+          });
+#else
+    m.attr("has_optional") = false;
+#endif
+
+    // #70 compilation issue if operator new is not public - simple body added
+    // but not needed on most compilers; MSVC and nvcc don't like a local
+    // struct not having a method defined when declared, since it can not be
+    // added later.
+    struct PrivateOpNew {
+        int value = 1;
+
+    private:
+        void *operator new(size_t bytes) {
+            void *ptr = std::malloc(bytes);
+            if (ptr) {
+                return ptr;
+            }
+            throw std::bad_alloc{};
+        }
+    };
+    py::class_<PrivateOpNew>(m, "PrivateOpNew").def_readonly("value", &PrivateOpNew::value);
+    m.def("private_op_new_value", []() { return PrivateOpNew(); });
+    m.def(
+        "private_op_new_reference",
+        []() -> const PrivateOpNew & {
+            static PrivateOpNew x{};
+            return x;
+        },
+        py::return_value_policy::reference);
+
+    // test_move_fallback
+    // #389: rvp::move should fall-through to copy on non-movable objects
+    struct MoveIssue1 {
+        int v;
+        explicit MoveIssue1(int v) : v{v} {}
+        MoveIssue1(const MoveIssue1 &c) = default;
+        MoveIssue1(MoveIssue1 &&) = delete;
+    };
+    py::class_<MoveIssue1>(m, "MoveIssue1")
+        .def(py::init<int>())
+        .def_readwrite("value", &MoveIssue1::v);
+
+    struct MoveIssue2 {
+        int v;
+        explicit MoveIssue2(int v) : v{v} {}
+        MoveIssue2(MoveIssue2 &&) = default;
+    };
+    py::class_<MoveIssue2>(m, "MoveIssue2")
+        .def(py::init<int>())
+        .def_readwrite("value", &MoveIssue2::v);
+
+    // #2742: Don't expect ownership of raw pointer to `new`ed object to be transferred with
+    // `py::return_value_policy::move`
+    m.def(
+        "get_moveissue1",
+        [](int i) { return std::unique_ptr<MoveIssue1>(new MoveIssue1(i)); },
+        py::return_value_policy::move);
+    m.def(
+        "get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
+
+    // Make sure that cast from pytype rvalue to other pytype works
+    m.def("get_pytype_rvalue_castissue", [](double i) { return py::float_(i).cast<py::int_>(); });
+}
+
+/*
+ * Rest of the file:
+ * static_assert based tests for pybind11 adaptations of
+ * std::is_move_constructible, std::is_copy_constructible and
+ * std::is_copy_assignable (no adaptation of std::is_move_assignable).
+ * Difference between pybind11 and std traits: pybind11 traits will also check
+ * the contained value_types.
+ */
+
+struct NotMovable {
+    NotMovable() = default;
+    NotMovable(NotMovable const &) = default;
+    NotMovable(NotMovable &&) = delete;
+    NotMovable &operator=(NotMovable const &) = default;
+    NotMovable &operator=(NotMovable &&) = delete;
+};
+static_assert(!std::is_move_constructible<NotMovable>::value,
+              "!std::is_move_constructible<NotMovable>::value");
+static_assert(std::is_copy_constructible<NotMovable>::value,
+              "std::is_copy_constructible<NotMovable>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotMovable>::value,
+              "!pybind11::detail::is_move_constructible<NotMovable>::value");
+static_assert(pybind11::detail::is_copy_constructible<NotMovable>::value,
+              "pybind11::detail::is_copy_constructible<NotMovable>::value");
+static_assert(!std::is_move_assignable<NotMovable>::value,
+              "!std::is_move_assignable<NotMovable>::value");
+static_assert(std::is_copy_assignable<NotMovable>::value,
+              "std::is_copy_assignable<NotMovable>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotMovable>::value,
+//               "!pybind11::detail::is_move_assignable<NotMovable>::value");
+static_assert(pybind11::detail::is_copy_assignable<NotMovable>::value,
+              "pybind11::detail::is_copy_assignable<NotMovable>::value");
+
+struct NotCopyable {
+    NotCopyable() = default;
+    NotCopyable(NotCopyable const &) = delete;
+    NotCopyable(NotCopyable &&) = default;
+    NotCopyable &operator=(NotCopyable const &) = delete;
+    NotCopyable &operator=(NotCopyable &&) = default;
+};
+static_assert(std::is_move_constructible<NotCopyable>::value,
+              "std::is_move_constructible<NotCopyable>::value");
+static_assert(!std::is_copy_constructible<NotCopyable>::value,
+              "!std::is_copy_constructible<NotCopyable>::value");
+static_assert(pybind11::detail::is_move_constructible<NotCopyable>::value,
+              "pybind11::detail::is_move_constructible<NotCopyable>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyable>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyable>::value");
+static_assert(std::is_move_assignable<NotCopyable>::value,
+              "std::is_move_assignable<NotCopyable>::value");
+static_assert(!std::is_copy_assignable<NotCopyable>::value,
+              "!std::is_copy_assignable<NotCopyable>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyable>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyable>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyable>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyable>::value");
+
+struct NotCopyableNotMovable {
+    NotCopyableNotMovable() = default;
+    NotCopyableNotMovable(NotCopyableNotMovable const &) = delete;
+    NotCopyableNotMovable(NotCopyableNotMovable &&) = delete;
+    NotCopyableNotMovable &operator=(NotCopyableNotMovable const &) = delete;
+    NotCopyableNotMovable &operator=(NotCopyableNotMovable &&) = delete;
+};
+static_assert(!std::is_move_constructible<NotCopyableNotMovable>::value,
+              "!std::is_move_constructible<NotCopyableNotMovable>::value");
+static_assert(!std::is_copy_constructible<NotCopyableNotMovable>::value,
+              "!std::is_copy_constructible<NotCopyableNotMovable>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value,
+              "!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value");
+static_assert(!std::is_move_assignable<NotCopyableNotMovable>::value,
+              "!std::is_move_assignable<NotCopyableNotMovable>::value");
+static_assert(!std::is_copy_assignable<NotCopyableNotMovable>::value,
+              "!std::is_copy_assignable<NotCopyableNotMovable>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value");
+
+struct NotMovableVector : std::vector<NotMovable> {};
+static_assert(std::is_move_constructible<NotMovableVector>::value,
+              "std::is_move_constructible<NotMovableVector>::value");
+static_assert(std::is_copy_constructible<NotMovableVector>::value,
+              "std::is_copy_constructible<NotMovableVector>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotMovableVector>::value,
+              "!pybind11::detail::is_move_constructible<NotMovableVector>::value");
+static_assert(pybind11::detail::is_copy_constructible<NotMovableVector>::value,
+              "pybind11::detail::is_copy_constructible<NotMovableVector>::value");
+static_assert(std::is_move_assignable<NotMovableVector>::value,
+              "std::is_move_assignable<NotMovableVector>::value");
+static_assert(std::is_copy_assignable<NotMovableVector>::value,
+              "std::is_copy_assignable<NotMovableVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotMovableVector>::value,
+//               "!pybind11::detail::is_move_assignable<NotMovableVector>::value");
+static_assert(pybind11::detail::is_copy_assignable<NotMovableVector>::value,
+              "pybind11::detail::is_copy_assignable<NotMovableVector>::value");
+
+struct NotCopyableVector : std::vector<NotCopyable> {};
+static_assert(std::is_move_constructible<NotCopyableVector>::value,
+              "std::is_move_constructible<NotCopyableVector>::value");
+static_assert(std::is_copy_constructible<NotCopyableVector>::value,
+              "std::is_copy_constructible<NotCopyableVector>::value");
+static_assert(pybind11::detail::is_move_constructible<NotCopyableVector>::value,
+              "pybind11::detail::is_move_constructible<NotCopyableVector>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableVector>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableVector>::value");
+static_assert(std::is_move_assignable<NotCopyableVector>::value,
+              "std::is_move_assignable<NotCopyableVector>::value");
+static_assert(std::is_copy_assignable<NotCopyableVector>::value,
+              "std::is_copy_assignable<NotCopyableVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableVector>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableVector>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableVector>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableVector>::value");
+
+struct NotCopyableNotMovableVector : std::vector<NotCopyableNotMovable> {};
+static_assert(std::is_move_constructible<NotCopyableNotMovableVector>::value,
+              "std::is_move_constructible<NotCopyableNotMovableVector>::value");
+static_assert(std::is_copy_constructible<NotCopyableNotMovableVector>::value,
+              "std::is_copy_constructible<NotCopyableNotMovableVector>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value,
+              "!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value");
+static_assert(std::is_move_assignable<NotCopyableNotMovableVector>::value,
+              "std::is_move_assignable<NotCopyableNotMovableVector>::value");
+static_assert(std::is_copy_assignable<NotCopyableNotMovableVector>::value,
+              "std::is_copy_assignable<NotCopyableNotMovableVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value");
+
+struct NotMovableMap : std::map<int, NotMovable> {};
+static_assert(std::is_move_constructible<NotMovableMap>::value,
+              "std::is_move_constructible<NotMovableMap>::value");
+static_assert(std::is_copy_constructible<NotMovableMap>::value,
+              "std::is_copy_constructible<NotMovableMap>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotMovableMap>::value,
+              "!pybind11::detail::is_move_constructible<NotMovableMap>::value");
+static_assert(pybind11::detail::is_copy_constructible<NotMovableMap>::value,
+              "pybind11::detail::is_copy_constructible<NotMovableMap>::value");
+static_assert(std::is_move_assignable<NotMovableMap>::value,
+              "std::is_move_assignable<NotMovableMap>::value");
+static_assert(std::is_copy_assignable<NotMovableMap>::value,
+              "std::is_copy_assignable<NotMovableMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotMovableMap>::value,
+//               "!pybind11::detail::is_move_assignable<NotMovableMap>::value");
+static_assert(pybind11::detail::is_copy_assignable<NotMovableMap>::value,
+              "pybind11::detail::is_copy_assignable<NotMovableMap>::value");
+
+struct NotCopyableMap : std::map<int, NotCopyable> {};
+static_assert(std::is_move_constructible<NotCopyableMap>::value,
+              "std::is_move_constructible<NotCopyableMap>::value");
+static_assert(std::is_copy_constructible<NotCopyableMap>::value,
+              "std::is_copy_constructible<NotCopyableMap>::value");
+static_assert(pybind11::detail::is_move_constructible<NotCopyableMap>::value,
+              "pybind11::detail::is_move_constructible<NotCopyableMap>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableMap>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableMap>::value");
+static_assert(std::is_move_assignable<NotCopyableMap>::value,
+              "std::is_move_assignable<NotCopyableMap>::value");
+static_assert(std::is_copy_assignable<NotCopyableMap>::value,
+              "std::is_copy_assignable<NotCopyableMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableMap>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableMap>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableMap>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableMap>::value");
+
+struct NotCopyableNotMovableMap : std::map<int, NotCopyableNotMovable> {};
+static_assert(std::is_move_constructible<NotCopyableNotMovableMap>::value,
+              "std::is_move_constructible<NotCopyableNotMovableMap>::value");
+static_assert(std::is_copy_constructible<NotCopyableNotMovableMap>::value,
+              "std::is_copy_constructible<NotCopyableNotMovableMap>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value,
+              "!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value");
+static_assert(std::is_move_assignable<NotCopyableNotMovableMap>::value,
+              "std::is_move_assignable<NotCopyableNotMovableMap>::value");
+static_assert(std::is_copy_assignable<NotCopyableNotMovableMap>::value,
+              "std::is_copy_assignable<NotCopyableNotMovableMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value");
+
+struct RecursiveVector : std::vector<RecursiveVector> {};
+static_assert(std::is_move_constructible<RecursiveVector>::value,
+              "std::is_move_constructible<RecursiveVector>::value");
+static_assert(std::is_copy_constructible<RecursiveVector>::value,
+              "std::is_copy_constructible<RecursiveVector>::value");
+static_assert(pybind11::detail::is_move_constructible<RecursiveVector>::value,
+              "pybind11::detail::is_move_constructible<RecursiveVector>::value");
+static_assert(pybind11::detail::is_copy_constructible<RecursiveVector>::value,
+              "pybind11::detail::is_copy_constructible<RecursiveVector>::value");
+static_assert(std::is_move_assignable<RecursiveVector>::value,
+              "std::is_move_assignable<RecursiveVector>::value");
+static_assert(std::is_copy_assignable<RecursiveVector>::value,
+              "std::is_copy_assignable<RecursiveVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<RecursiveVector>::value,
+//               "!pybind11::detail::is_move_assignable<RecursiveVector>::value");
+static_assert(pybind11::detail::is_copy_assignable<RecursiveVector>::value,
+              "pybind11::detail::is_copy_assignable<RecursiveVector>::value");
+
+struct RecursiveMap : std::map<int, RecursiveMap> {};
+static_assert(std::is_move_constructible<RecursiveMap>::value,
+              "std::is_move_constructible<RecursiveMap>::value");
+static_assert(std::is_copy_constructible<RecursiveMap>::value,
+              "std::is_copy_constructible<RecursiveMap>::value");
+static_assert(pybind11::detail::is_move_constructible<RecursiveMap>::value,
+              "pybind11::detail::is_move_constructible<RecursiveMap>::value");
+static_assert(pybind11::detail::is_copy_constructible<RecursiveMap>::value,
+              "pybind11::detail::is_copy_constructible<RecursiveMap>::value");
+static_assert(std::is_move_assignable<RecursiveMap>::value,
+              "std::is_move_assignable<RecursiveMap>::value");
+static_assert(std::is_copy_assignable<RecursiveMap>::value,
+              "std::is_copy_assignable<RecursiveMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<RecursiveMap>::value,
+//               "!pybind11::detail::is_move_assignable<RecursiveMap>::value");
+static_assert(pybind11::detail::is_copy_assignable<RecursiveMap>::value,
+              "pybind11::detail::is_copy_assignable<RecursiveMap>::value");

third_party/CityFlow/extern/pybind11/tests/test_copy_move.py

@@ -1,132 +1,132 @@
-import pytest
-
-from pybind11_tests import copy_move_policies as m
-
-
-def test_lacking_copy_ctor():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.lacking_copy_ctor.get_one()
-    assert "is non-copyable!" in str(excinfo.value)
-
-
-def test_lacking_move_ctor():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.lacking_move_ctor.get_one()
-    assert "is neither movable nor copyable!" in str(excinfo.value)
-
-
-def test_move_and_copy_casts():
-    """Cast some values in C++ via custom type casters and count the number of moves/copies."""
-
-    cstats = m.move_and_copy_cstats()
-    c_m, c_mc, c_c = (
-        cstats["MoveOnlyInt"],
-        cstats["MoveOrCopyInt"],
-        cstats["CopyOnlyInt"],
-    )
-
-    # The type move constructions/assignments below each get incremented: the move assignment comes
-    # from the type_caster load; the move construction happens when extracting that via a cast or
-    # loading into an argument.
-    assert m.move_and_copy_casts(3) == 18
-    assert c_m.copy_assignments + c_m.copy_constructions == 0
-    assert c_m.move_assignments == 2
-    assert c_m.move_constructions >= 2
-    assert c_mc.alive() == 0
-    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
-    assert c_mc.move_assignments == 2
-    assert c_mc.move_constructions >= 2
-    assert c_c.alive() == 0
-    assert c_c.copy_assignments == 2
-    assert c_c.copy_constructions >= 2
-    assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
-
-
-def test_move_and_copy_loads():
-    """Call some functions that load arguments via custom type casters and count the number of
-    moves/copies."""
-
-    cstats = m.move_and_copy_cstats()
-    c_m, c_mc, c_c = (
-        cstats["MoveOnlyInt"],
-        cstats["MoveOrCopyInt"],
-        cstats["CopyOnlyInt"],
-    )
-
-    assert m.move_only(10) == 10  # 1 move, c_m
-    assert m.move_or_copy(11) == 11  # 1 move, c_mc
-    assert m.copy_only(12) == 12  # 1 copy, c_c
-    assert m.move_pair((13, 14)) == 27  # 1 c_m move, 1 c_mc move
-    assert m.move_tuple((15, 16, 17)) == 48  # 2 c_m moves, 1 c_mc move
-    assert m.copy_tuple((18, 19)) == 37  # 2 c_c copies
-    # Direct constructions: 2 c_m moves, 2 c_mc moves, 1 c_c copy
-    # Extra moves/copies when moving pairs/tuples: 3 c_m, 3 c_mc, 2 c_c
-    assert m.move_copy_nested((1, ((2, 3, (4,)), 5))) == 15
-
-    assert c_m.copy_assignments + c_m.copy_constructions == 0
-    assert c_m.move_assignments == 6
-    assert c_m.move_constructions == 9
-    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
-    assert c_mc.move_assignments == 5
-    assert c_mc.move_constructions == 8
-    assert c_c.copy_assignments == 4
-    assert c_c.copy_constructions == 6
-    assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
-
-
-@pytest.mark.skipif(not m.has_optional, reason="no <optional>")
-def test_move_and_copy_load_optional():
-    """Tests move/copy loads of std::optional arguments"""
-
-    cstats = m.move_and_copy_cstats()
-    c_m, c_mc, c_c = (
-        cstats["MoveOnlyInt"],
-        cstats["MoveOrCopyInt"],
-        cstats["CopyOnlyInt"],
-    )
-
-    # The extra move/copy constructions below come from the std::optional move (which has to move
-    # its arguments):
-    assert m.move_optional(10) == 10  # c_m: 1 move assign, 2 move construct
-    assert m.move_or_copy_optional(11) == 11  # c_mc: 1 move assign, 2 move construct
-    assert m.copy_optional(12) == 12  # c_c: 1 copy assign, 2 copy construct
-    # 1 move assign + move construct moves each of c_m, c_mc, 1 c_c copy
-    # +1 move/copy construct each from moving the tuple
-    # +1 move/copy construct each from moving the optional (which moves the tuple again)
-    assert m.move_optional_tuple((3, 4, 5)) == 12
-
-    assert c_m.copy_assignments + c_m.copy_constructions == 0
-    assert c_m.move_assignments == 2
-    assert c_m.move_constructions == 5
-    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
-    assert c_mc.move_assignments == 2
-    assert c_mc.move_constructions == 5
-    assert c_c.copy_assignments == 2
-    assert c_c.copy_constructions == 5
-    assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
-
-
-def test_private_op_new():
-    """An object with a private `operator new` cannot be returned by value"""
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.private_op_new_value()
-    assert "is neither movable nor copyable" in str(excinfo.value)
-
-    assert m.private_op_new_reference().value == 1
-
-
-def test_move_fallback():
-    """#389: rvp::move should fall-through to copy on non-movable objects"""
-
-    m1 = m.get_moveissue1(1)
-    assert m1.value == 1
-    m2 = m.get_moveissue2(2)
-    assert m2.value == 2
-
-
-def test_pytype_rvalue_cast():
-    """Make sure that cast from pytype rvalue to other pytype works"""
-
-    value = m.get_pytype_rvalue_castissue(1.0)
-    assert value == 1
+import pytest
+
+from pybind11_tests import copy_move_policies as m
+
+
+def test_lacking_copy_ctor():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.lacking_copy_ctor.get_one()
+    assert "is non-copyable!" in str(excinfo.value)
+
+
+def test_lacking_move_ctor():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.lacking_move_ctor.get_one()
+    assert "is neither movable nor copyable!" in str(excinfo.value)
+
+
+def test_move_and_copy_casts():
+    """Cast some values in C++ via custom type casters and count the number of moves/copies."""
+
+    cstats = m.move_and_copy_cstats()
+    c_m, c_mc, c_c = (
+        cstats["MoveOnlyInt"],
+        cstats["MoveOrCopyInt"],
+        cstats["CopyOnlyInt"],
+    )
+
+    # The type move constructions/assignments below each get incremented: the move assignment comes
+    # from the type_caster load; the move construction happens when extracting that via a cast or
+    # loading into an argument.
+    assert m.move_and_copy_casts(3) == 18
+    assert c_m.copy_assignments + c_m.copy_constructions == 0
+    assert c_m.move_assignments == 2
+    assert c_m.move_constructions >= 2
+    assert c_mc.alive() == 0
+    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
+    assert c_mc.move_assignments == 2
+    assert c_mc.move_constructions >= 2
+    assert c_c.alive() == 0
+    assert c_c.copy_assignments == 2
+    assert c_c.copy_constructions >= 2
+    assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
+
+
+def test_move_and_copy_loads():
+    """Call some functions that load arguments via custom type casters and count the number of
+    moves/copies."""
+
+    cstats = m.move_and_copy_cstats()
+    c_m, c_mc, c_c = (
+        cstats["MoveOnlyInt"],
+        cstats["MoveOrCopyInt"],
+        cstats["CopyOnlyInt"],
+    )
+
+    assert m.move_only(10) == 10  # 1 move, c_m
+    assert m.move_or_copy(11) == 11  # 1 move, c_mc
+    assert m.copy_only(12) == 12  # 1 copy, c_c
+    assert m.move_pair((13, 14)) == 27  # 1 c_m move, 1 c_mc move
+    assert m.move_tuple((15, 16, 17)) == 48  # 2 c_m moves, 1 c_mc move
+    assert m.copy_tuple((18, 19)) == 37  # 2 c_c copies
+    # Direct constructions: 2 c_m moves, 2 c_mc moves, 1 c_c copy
+    # Extra moves/copies when moving pairs/tuples: 3 c_m, 3 c_mc, 2 c_c
+    assert m.move_copy_nested((1, ((2, 3, (4,)), 5))) == 15
+
+    assert c_m.copy_assignments + c_m.copy_constructions == 0
+    assert c_m.move_assignments == 6
+    assert c_m.move_constructions == 9
+    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
+    assert c_mc.move_assignments == 5
+    assert c_mc.move_constructions == 8
+    assert c_c.copy_assignments == 4
+    assert c_c.copy_constructions == 6
+    assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
+
+
+@pytest.mark.skipif(not m.has_optional, reason="no <optional>")
+def test_move_and_copy_load_optional():
+    """Tests move/copy loads of std::optional arguments"""
+
+    cstats = m.move_and_copy_cstats()
+    c_m, c_mc, c_c = (
+        cstats["MoveOnlyInt"],
+        cstats["MoveOrCopyInt"],
+        cstats["CopyOnlyInt"],
+    )
+
+    # The extra move/copy constructions below come from the std::optional move (which has to move
+    # its arguments):
+    assert m.move_optional(10) == 10  # c_m: 1 move assign, 2 move construct
+    assert m.move_or_copy_optional(11) == 11  # c_mc: 1 move assign, 2 move construct
+    assert m.copy_optional(12) == 12  # c_c: 1 copy assign, 2 copy construct
+    # 1 move assign + move construct moves each of c_m, c_mc, 1 c_c copy
+    # +1 move/copy construct each from moving the tuple
+    # +1 move/copy construct each from moving the optional (which moves the tuple again)
+    assert m.move_optional_tuple((3, 4, 5)) == 12
+
+    assert c_m.copy_assignments + c_m.copy_constructions == 0
+    assert c_m.move_assignments == 2
+    assert c_m.move_constructions == 5
+    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
+    assert c_mc.move_assignments == 2
+    assert c_mc.move_constructions == 5
+    assert c_c.copy_assignments == 2
+    assert c_c.copy_constructions == 5
+    assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
+
+
+def test_private_op_new():
+    """An object with a private `operator new` cannot be returned by value"""
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m.private_op_new_value()
+    assert "is neither movable nor copyable" in str(excinfo.value)
+
+    assert m.private_op_new_reference().value == 1
+
+
+def test_move_fallback():
+    """#389: rvp::move should fall-through to copy on non-movable objects"""
+
+    m1 = m.get_moveissue1(1)
+    assert m1.value == 1
+    m2 = m.get_moveissue2(2)
+    assert m2.value == 2
+
+
+def test_pytype_rvalue_cast():
+    """Make sure that cast from pytype rvalue to other pytype works"""
+
+    value = m.get_pytype_rvalue_castissue(1.0)
+    assert value == 1

third_party/CityFlow/extern/pybind11/tests/test_custom_type_casters.cpp

@@ -1,221 +1,221 @@
-/*
-    tests/test_custom_type_casters.cpp -- tests type_caster<T>
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "constructor_stats.h"
-#include "pybind11_tests.h"
-
-// py::arg/py::arg_v testing: these arguments just record their argument when invoked
-class ArgInspector1 {
-public:
-    std::string arg = "(default arg inspector 1)";
-};
-class ArgInspector2 {
-public:
-    std::string arg = "(default arg inspector 2)";
-};
-class ArgAlwaysConverts {};
-
-namespace PYBIND11_NAMESPACE {
-namespace detail {
-template <>
-struct type_caster<ArgInspector1> {
-public:
-    // Classic
-#ifdef PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY
-    PYBIND11_TYPE_CASTER(ArgInspector1, _("ArgInspector1"));
-#else
-    PYBIND11_TYPE_CASTER(ArgInspector1, const_name("ArgInspector1"));
-#endif
-
-    bool load(handle src, bool convert) {
-        value.arg = "loading ArgInspector1 argument " + std::string(convert ? "WITH" : "WITHOUT")
-                    + " conversion allowed.  "
-                      "Argument value = "
-                    + (std::string) str(src);
-        return true;
-    }
-
-    static handle cast(const ArgInspector1 &src, return_value_policy, handle) {
-        return str(src.arg).release();
-    }
-};
-template <>
-struct type_caster<ArgInspector2> {
-public:
-    PYBIND11_TYPE_CASTER(ArgInspector2, const_name("ArgInspector2"));
-
-    bool load(handle src, bool convert) {
-        value.arg = "loading ArgInspector2 argument " + std::string(convert ? "WITH" : "WITHOUT")
-                    + " conversion allowed.  "
-                      "Argument value = "
-                    + (std::string) str(src);
-        return true;
-    }
-
-    static handle cast(const ArgInspector2 &src, return_value_policy, handle) {
-        return str(src.arg).release();
-    }
-};
-template <>
-struct type_caster<ArgAlwaysConverts> {
-public:
-    PYBIND11_TYPE_CASTER(ArgAlwaysConverts, const_name("ArgAlwaysConverts"));
-
-    bool load(handle, bool convert) { return convert; }
-
-    static handle cast(const ArgAlwaysConverts &, return_value_policy, handle) {
-        return py::none().release();
-    }
-};
-} // namespace detail
-} // namespace PYBIND11_NAMESPACE
-
-// test_custom_caster_destruction
-class DestructionTester {
-public:
-    DestructionTester() { print_default_created(this); }
-    ~DestructionTester() { print_destroyed(this); }
-    DestructionTester(const DestructionTester &) { print_copy_created(this); }
-    DestructionTester(DestructionTester &&) noexcept { print_move_created(this); }
-    DestructionTester &operator=(const DestructionTester &) {
-        print_copy_assigned(this);
-        return *this;
-    }
-    DestructionTester &operator=(DestructionTester &&) noexcept {
-        print_move_assigned(this);
-        return *this;
-    }
-};
-namespace PYBIND11_NAMESPACE {
-namespace detail {
-template <>
-struct type_caster<DestructionTester> {
-    PYBIND11_TYPE_CASTER(DestructionTester, const_name("DestructionTester"));
-    bool load(handle, bool) { return true; }
-
-    static handle cast(const DestructionTester &, return_value_policy, handle) {
-        return py::bool_(true).release();
-    }
-};
-} // namespace detail
-} // namespace PYBIND11_NAMESPACE
-
-// Define type caster outside of `pybind11::detail` and then alias it.
-namespace other_lib {
-struct MyType {};
-// Corrupt `py` shorthand alias for surrounding context.
-namespace py {}
-// Corrupt unqualified relative `pybind11` namespace.
-namespace PYBIND11_NAMESPACE {}
-// Correct alias.
-namespace py_ = ::pybind11;
-// Define caster. This is effectively no-op, we only ensure it compiles and we
-// don't have any symbol collision when using macro mixin.
-struct my_caster {
-    PYBIND11_TYPE_CASTER(MyType, py_::detail::const_name("MyType"));
-    bool load(py_::handle, bool) { return true; }
-
-    static py_::handle cast(const MyType &, py_::return_value_policy, py_::handle) {
-        return py_::bool_(true).release();
-    }
-};
-} // namespace other_lib
-// Effectively "alias" it into correct namespace (via inheritance).
-namespace PYBIND11_NAMESPACE {
-namespace detail {
-template <>
-struct type_caster<other_lib::MyType> : public other_lib::my_caster {};
-} // namespace detail
-} // namespace PYBIND11_NAMESPACE
-
-// This simply is required to compile
-namespace ADL_issue {
-template <typename OutStringType = std::string, typename... Args>
-OutStringType concat(Args &&...) {
-    return OutStringType();
-}
-
-struct test {};
-} // namespace ADL_issue
-
-TEST_SUBMODULE(custom_type_casters, m) {
-    // test_custom_type_casters
-
-    // test_noconvert_args
-    //
-    // Test converting.  The ArgAlwaysConverts is just there to make the first no-conversion pass
-    // fail so that our call always ends up happening via the second dispatch (the one that allows
-    // some conversion).
-    class ArgInspector {
-    public:
-        ArgInspector1 f(ArgInspector1 a, ArgAlwaysConverts) { return a; }
-        std::string g(const ArgInspector1 &a,
-                      const ArgInspector1 &b,
-                      int c,
-                      ArgInspector2 *d,
-                      ArgAlwaysConverts) {
-            return a.arg + "\n" + b.arg + "\n" + std::to_string(c) + "\n" + d->arg;
-        }
-        static ArgInspector2 h(ArgInspector2 a, ArgAlwaysConverts) { return a; }
-    };
-    // [workaround(intel)] ICC 20/21 breaks with py::arg().stuff, using py::arg{}.stuff works.
-    py::class_<ArgInspector>(m, "ArgInspector")
-        .def(py::init<>())
-        .def("f", &ArgInspector::f, py::arg(), py::arg() = ArgAlwaysConverts())
-        .def("g",
-             &ArgInspector::g,
-             "a"_a.noconvert(),
-             "b"_a,
-             "c"_a.noconvert() = 13,
-             "d"_a = ArgInspector2(),
-             py::arg() = ArgAlwaysConverts())
-        .def_static("h", &ArgInspector::h, py::arg{}.noconvert(), py::arg() = ArgAlwaysConverts());
-    m.def(
-        "arg_inspect_func",
-        [](const ArgInspector2 &a, const ArgInspector1 &b, ArgAlwaysConverts) {
-            return a.arg + "\n" + b.arg;
-        },
-        py::arg{}.noconvert(false),
-        py::arg_v(nullptr, ArgInspector1()).noconvert(true),
-        py::arg() = ArgAlwaysConverts());
-
-    m.def(
-        "floats_preferred", [](double f) { return 0.5 * f; }, "f"_a);
-    m.def(
-        "floats_only", [](double f) { return 0.5 * f; }, "f"_a.noconvert());
-    m.def(
-        "ints_preferred", [](int i) { return i / 2; }, "i"_a);
-    m.def(
-        "ints_only", [](int i) { return i / 2; }, "i"_a.noconvert());
-
-    // test_custom_caster_destruction
-    // Test that `take_ownership` works on types with a custom type caster when given a pointer
-
-    // default policy: don't take ownership:
-    m.def("custom_caster_no_destroy", []() {
-        static auto *dt = new DestructionTester();
-        return dt;
-    });
-
-    m.def(
-        "custom_caster_destroy",
-        []() { return new DestructionTester(); },
-        py::return_value_policy::take_ownership); // Takes ownership: destroy when finished
-    m.def(
-        "custom_caster_destroy_const",
-        []() -> const DestructionTester * { return new DestructionTester(); },
-        py::return_value_policy::take_ownership); // Likewise (const doesn't inhibit destruction)
-    m.def("destruction_tester_cstats",
-          &ConstructorStats::get<DestructionTester>,
-          py::return_value_policy::reference);
-
-    m.def("other_lib_type", [](other_lib::MyType x) { return x; });
-
-    m.def("_adl_issue", [](const ADL_issue::test &) {});
-}
+/*
+    tests/test_custom_type_casters.cpp -- tests type_caster<T>
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "constructor_stats.h"
+#include "pybind11_tests.h"
+
+// py::arg/py::arg_v testing: these arguments just record their argument when invoked
+class ArgInspector1 {
+public:
+    std::string arg = "(default arg inspector 1)";
+};
+class ArgInspector2 {
+public:
+    std::string arg = "(default arg inspector 2)";
+};
+class ArgAlwaysConverts {};
+
+namespace PYBIND11_NAMESPACE {
+namespace detail {
+template <>
+struct type_caster<ArgInspector1> {
+public:
+    // Classic
+#ifdef PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY
+    PYBIND11_TYPE_CASTER(ArgInspector1, _("ArgInspector1"));
+#else
+    PYBIND11_TYPE_CASTER(ArgInspector1, const_name("ArgInspector1"));
+#endif
+
+    bool load(handle src, bool convert) {
+        value.arg = "loading ArgInspector1 argument " + std::string(convert ? "WITH" : "WITHOUT")
+                    + " conversion allowed.  "
+                      "Argument value = "
+                    + (std::string) str(src);
+        return true;
+    }
+
+    static handle cast(const ArgInspector1 &src, return_value_policy, handle) {
+        return str(src.arg).release();
+    }
+};
+template <>
+struct type_caster<ArgInspector2> {
+public:
+    PYBIND11_TYPE_CASTER(ArgInspector2, const_name("ArgInspector2"));
+
+    bool load(handle src, bool convert) {
+        value.arg = "loading ArgInspector2 argument " + std::string(convert ? "WITH" : "WITHOUT")
+                    + " conversion allowed.  "
+                      "Argument value = "
+                    + (std::string) str(src);
+        return true;
+    }
+
+    static handle cast(const ArgInspector2 &src, return_value_policy, handle) {
+        return str(src.arg).release();
+    }
+};
+template <>
+struct type_caster<ArgAlwaysConverts> {
+public:
+    PYBIND11_TYPE_CASTER(ArgAlwaysConverts, const_name("ArgAlwaysConverts"));
+
+    bool load(handle, bool convert) { return convert; }
+
+    static handle cast(const ArgAlwaysConverts &, return_value_policy, handle) {
+        return py::none().release();
+    }
+};
+} // namespace detail
+} // namespace PYBIND11_NAMESPACE
+
+// test_custom_caster_destruction
+class DestructionTester {
+public:
+    DestructionTester() { print_default_created(this); }
+    ~DestructionTester() { print_destroyed(this); }
+    DestructionTester(const DestructionTester &) { print_copy_created(this); }
+    DestructionTester(DestructionTester &&) noexcept { print_move_created(this); }
+    DestructionTester &operator=(const DestructionTester &) {
+        print_copy_assigned(this);
+        return *this;
+    }
+    DestructionTester &operator=(DestructionTester &&) noexcept {
+        print_move_assigned(this);
+        return *this;
+    }
+};
+namespace PYBIND11_NAMESPACE {
+namespace detail {
+template <>
+struct type_caster<DestructionTester> {
+    PYBIND11_TYPE_CASTER(DestructionTester, const_name("DestructionTester"));
+    bool load(handle, bool) { return true; }
+
+    static handle cast(const DestructionTester &, return_value_policy, handle) {
+        return py::bool_(true).release();
+    }
+};
+} // namespace detail
+} // namespace PYBIND11_NAMESPACE
+
+// Define type caster outside of `pybind11::detail` and then alias it.
+namespace other_lib {
+struct MyType {};
+// Corrupt `py` shorthand alias for surrounding context.
+namespace py {}
+// Corrupt unqualified relative `pybind11` namespace.
+namespace PYBIND11_NAMESPACE {}
+// Correct alias.
+namespace py_ = ::pybind11;
+// Define caster. This is effectively no-op, we only ensure it compiles and we
+// don't have any symbol collision when using macro mixin.
+struct my_caster {
+    PYBIND11_TYPE_CASTER(MyType, py_::detail::const_name("MyType"));
+    bool load(py_::handle, bool) { return true; }
+
+    static py_::handle cast(const MyType &, py_::return_value_policy, py_::handle) {
+        return py_::bool_(true).release();
+    }
+};
+} // namespace other_lib
+// Effectively "alias" it into correct namespace (via inheritance).
+namespace PYBIND11_NAMESPACE {
+namespace detail {
+template <>
+struct type_caster<other_lib::MyType> : public other_lib::my_caster {};
+} // namespace detail
+} // namespace PYBIND11_NAMESPACE
+
+// This simply is required to compile
+namespace ADL_issue {
+template <typename OutStringType = std::string, typename... Args>
+OutStringType concat(Args &&...) {
+    return OutStringType();
+}
+
+struct test {};
+} // namespace ADL_issue
+
+TEST_SUBMODULE(custom_type_casters, m) {
+    // test_custom_type_casters
+
+    // test_noconvert_args
+    //
+    // Test converting.  The ArgAlwaysConverts is just there to make the first no-conversion pass
+    // fail so that our call always ends up happening via the second dispatch (the one that allows
+    // some conversion).
+    class ArgInspector {
+    public:
+        ArgInspector1 f(ArgInspector1 a, ArgAlwaysConverts) { return a; }
+        std::string g(const ArgInspector1 &a,
+                      const ArgInspector1 &b,
+                      int c,
+                      ArgInspector2 *d,
+                      ArgAlwaysConverts) {
+            return a.arg + "\n" + b.arg + "\n" + std::to_string(c) + "\n" + d->arg;
+        }
+        static ArgInspector2 h(ArgInspector2 a, ArgAlwaysConverts) { return a; }
+    };
+    // [workaround(intel)] ICC 20/21 breaks with py::arg().stuff, using py::arg{}.stuff works.
+    py::class_<ArgInspector>(m, "ArgInspector")
+        .def(py::init<>())
+        .def("f", &ArgInspector::f, py::arg(), py::arg() = ArgAlwaysConverts())
+        .def("g",
+             &ArgInspector::g,
+             "a"_a.noconvert(),
+             "b"_a,
+             "c"_a.noconvert() = 13,
+             "d"_a = ArgInspector2(),
+             py::arg() = ArgAlwaysConverts())
+        .def_static("h", &ArgInspector::h, py::arg{}.noconvert(), py::arg() = ArgAlwaysConverts());
+    m.def(
+        "arg_inspect_func",
+        [](const ArgInspector2 &a, const ArgInspector1 &b, ArgAlwaysConverts) {
+            return a.arg + "\n" + b.arg;
+        },
+        py::arg{}.noconvert(false),
+        py::arg_v(nullptr, ArgInspector1()).noconvert(true),
+        py::arg() = ArgAlwaysConverts());
+
+    m.def(
+        "floats_preferred", [](double f) { return 0.5 * f; }, "f"_a);
+    m.def(
+        "floats_only", [](double f) { return 0.5 * f; }, "f"_a.noconvert());
+    m.def(
+        "ints_preferred", [](int i) { return i / 2; }, "i"_a);
+    m.def(
+        "ints_only", [](int i) { return i / 2; }, "i"_a.noconvert());
+
+    // test_custom_caster_destruction
+    // Test that `take_ownership` works on types with a custom type caster when given a pointer
+
+    // default policy: don't take ownership:
+    m.def("custom_caster_no_destroy", []() {
+        static auto *dt = new DestructionTester();
+        return dt;
+    });
+
+    m.def(
+        "custom_caster_destroy",
+        []() { return new DestructionTester(); },
+        py::return_value_policy::take_ownership); // Takes ownership: destroy when finished
+    m.def(
+        "custom_caster_destroy_const",
+        []() -> const DestructionTester * { return new DestructionTester(); },
+        py::return_value_policy::take_ownership); // Likewise (const doesn't inhibit destruction)
+    m.def("destruction_tester_cstats",
+          &ConstructorStats::get<DestructionTester>,
+          py::return_value_policy::reference);
+
+    m.def("other_lib_type", [](other_lib::MyType x) { return x; });
+
+    m.def("_adl_issue", [](const ADL_issue::test &) {});
+}

third_party/CityFlow/extern/pybind11/tests/test_custom_type_casters.py

@@ -1,122 +1,122 @@
-import pytest
-
-from pybind11_tests import custom_type_casters as m
-
-
-def test_noconvert_args(msg):
-    a = m.ArgInspector()
-    assert (
-        msg(a.f("hi"))
-        == """
-        loading ArgInspector1 argument WITH conversion allowed.  Argument value = hi
-    """
-    )
-    assert (
-        msg(a.g("this is a", "this is b"))
-        == """
-        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = this is a
-        loading ArgInspector1 argument WITH conversion allowed.  Argument value = this is b
-        13
-        loading ArgInspector2 argument WITH conversion allowed.  Argument value = (default arg inspector 2)
-    """
-    )
-    assert (
-        msg(a.g("this is a", "this is b", 42))
-        == """
-        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = this is a
-        loading ArgInspector1 argument WITH conversion allowed.  Argument value = this is b
-        42
-        loading ArgInspector2 argument WITH conversion allowed.  Argument value = (default arg inspector 2)
-    """
-    )
-    assert (
-        msg(a.g("this is a", "this is b", 42, "this is d"))
-        == """
-        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = this is a
-        loading ArgInspector1 argument WITH conversion allowed.  Argument value = this is b
-        42
-        loading ArgInspector2 argument WITH conversion allowed.  Argument value = this is d
-    """
-    )
-    assert (
-        a.h("arg 1")
-        == "loading ArgInspector2 argument WITHOUT conversion allowed.  Argument value = arg 1"
-    )
-    assert (
-        msg(m.arg_inspect_func("A1", "A2"))
-        == """
-        loading ArgInspector2 argument WITH conversion allowed.  Argument value = A1
-        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = A2
-    """
-    )
-
-    assert m.floats_preferred(4) == 2.0
-    assert m.floats_only(4.0) == 2.0
-    with pytest.raises(TypeError) as excinfo:
-        m.floats_only(4)
-    assert (
-        msg(excinfo.value)
-        == """
-        floats_only(): incompatible function arguments. The following argument types are supported:
-            1. (f: float) -> float
-
-        Invoked with: 4
-    """
-    )
-
-    assert m.ints_preferred(4) == 2
-    assert m.ints_preferred(True) == 0
-    with pytest.raises(TypeError) as excinfo:
-        m.ints_preferred(4.0)
-    assert (
-        msg(excinfo.value)
-        == """
-        ints_preferred(): incompatible function arguments. The following argument types are supported:
-            1. (i: int) -> int
-
-        Invoked with: 4.0
-    """
-    )
-
-    assert m.ints_only(4) == 2
-    with pytest.raises(TypeError) as excinfo:
-        m.ints_only(4.0)
-    assert (
-        msg(excinfo.value)
-        == """
-        ints_only(): incompatible function arguments. The following argument types are supported:
-            1. (i: int) -> int
-
-        Invoked with: 4.0
-    """
-    )
-
-
-def test_custom_caster_destruction():
-    """Tests that returning a pointer to a type that gets converted with a custom type caster gets
-    destroyed when the function has py::return_value_policy::take_ownership policy applied.
-    """
-
-    cstats = m.destruction_tester_cstats()
-    # This one *doesn't* have take_ownership: the pointer should be used but not destroyed:
-    z = m.custom_caster_no_destroy()
-    assert cstats.alive() == 1
-    assert cstats.default_constructions == 1
-    assert z
-
-    # take_ownership applied: this constructs a new object, casts it, then destroys it:
-    z = m.custom_caster_destroy()
-    assert z
-    assert cstats.default_constructions == 2
-
-    # Same, but with a const pointer return (which should *not* inhibit destruction):
-    z = m.custom_caster_destroy_const()
-    assert z
-    assert cstats.default_constructions == 3
-
-    # Make sure we still only have the original object (from ..._no_destroy()) alive:
-    assert cstats.alive() == 1
-
-
-def test_custom_caster_other_lib():
-    assert m.other_lib_type(True)
+import pytest
+
+from pybind11_tests import custom_type_casters as m
+
+
+def test_noconvert_args(msg):
+    a = m.ArgInspector()
+    assert (
+        msg(a.f("hi"))
+        == """
+        loading ArgInspector1 argument WITH conversion allowed.  Argument value = hi
+    """
+    )
+    assert (
+        msg(a.g("this is a", "this is b"))
+        == """
+        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = this is a
+        loading ArgInspector1 argument WITH conversion allowed.  Argument value = this is b
+        13
+        loading ArgInspector2 argument WITH conversion allowed.  Argument value = (default arg inspector 2)
+    """
+    )
+    assert (
+        msg(a.g("this is a", "this is b", 42))
+        == """
+        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = this is a
+        loading ArgInspector1 argument WITH conversion allowed.  Argument value = this is b
+        42
+        loading ArgInspector2 argument WITH conversion allowed.  Argument value = (default arg inspector 2)
+    """
+    )
+    assert (
+        msg(a.g("this is a", "this is b", 42, "this is d"))
+        == """
+        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = this is a
+        loading ArgInspector1 argument WITH conversion allowed.  Argument value = this is b
+        42
+        loading ArgInspector2 argument WITH conversion allowed.  Argument value = this is d
+    """
+    )
+    assert (
+        a.h("arg 1")
+        == "loading ArgInspector2 argument WITHOUT conversion allowed.  Argument value = arg 1"
+    )
+    assert (
+        msg(m.arg_inspect_func("A1", "A2"))
+        == """
+        loading ArgInspector2 argument WITH conversion allowed.  Argument value = A1
+        loading ArgInspector1 argument WITHOUT conversion allowed.  Argument value = A2
+    """
+    )
+
+    assert m.floats_preferred(4) == 2.0
+    assert m.floats_only(4.0) == 2.0
+    with pytest.raises(TypeError) as excinfo:
+        m.floats_only(4)
+    assert (
+        msg(excinfo.value)
+        == """
+        floats_only(): incompatible function arguments. The following argument types are supported:
+            1. (f: float) -> float
+
+        Invoked with: 4
+    """
+    )
+
+    assert m.ints_preferred(4) == 2
+    assert m.ints_preferred(True) == 0
+    with pytest.raises(TypeError) as excinfo:
+        m.ints_preferred(4.0)
+    assert (
+        msg(excinfo.value)
+        == """
+        ints_preferred(): incompatible function arguments. The following argument types are supported:
+            1. (i: int) -> int
+
+        Invoked with: 4.0
+    """
+    )
+
+    assert m.ints_only(4) == 2
+    with pytest.raises(TypeError) as excinfo:
+        m.ints_only(4.0)
+    assert (
+        msg(excinfo.value)
+        == """
+        ints_only(): incompatible function arguments. The following argument types are supported:
+            1. (i: int) -> int
+
+        Invoked with: 4.0
+    """
+    )
+
+
+def test_custom_caster_destruction():
+    """Tests that returning a pointer to a type that gets converted with a custom type caster gets
+    destroyed when the function has py::return_value_policy::take_ownership policy applied.
+    """
+
+    cstats = m.destruction_tester_cstats()
+    # This one *doesn't* have take_ownership: the pointer should be used but not destroyed:
+    z = m.custom_caster_no_destroy()
+    assert cstats.alive() == 1
+    assert cstats.default_constructions == 1
+    assert z
+
+    # take_ownership applied: this constructs a new object, casts it, then destroys it:
+    z = m.custom_caster_destroy()
+    assert z
+    assert cstats.default_constructions == 2
+
+    # Same, but with a const pointer return (which should *not* inhibit destruction):
+    z = m.custom_caster_destroy_const()
+    assert z
+    assert cstats.default_constructions == 3
+
+    # Make sure we still only have the original object (from ..._no_destroy()) alive:
+    assert cstats.alive() == 1
+
+
+def test_custom_caster_other_lib():
+    assert m.other_lib_type(True)

third_party/CityFlow/extern/pybind11/tests/test_custom_type_setup.cpp

@@ -1,41 +1,41 @@
-/*
-    tests/test_custom_type_setup.cpp -- Tests `pybind11::custom_type_setup`
-
-    Copyright (c) Google LLC
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/pybind11.h>
-
-#include "pybind11_tests.h"
-
-namespace py = pybind11;
-
-namespace {
-
-struct OwnsPythonObjects {
-    py::object value = py::none();
-};
-} // namespace
-
-TEST_SUBMODULE(custom_type_setup, m) {
-    py::class_<OwnsPythonObjects> cls(
-        m, "OwnsPythonObjects", py::custom_type_setup([](PyHeapTypeObject *heap_type) {
-            auto *type = &heap_type->ht_type;
-            type->tp_flags |= Py_TPFLAGS_HAVE_GC;
-            type->tp_traverse = [](PyObject *self_base, visitproc visit, void *arg) {
-                auto &self = py::cast<OwnsPythonObjects &>(py::handle(self_base));
-                Py_VISIT(self.value.ptr());
-                return 0;
-            };
-            type->tp_clear = [](PyObject *self_base) {
-                auto &self = py::cast<OwnsPythonObjects &>(py::handle(self_base));
-                self.value = py::none();
-                return 0;
-            };
-        }));
-    cls.def(py::init<>());
-    cls.def_readwrite("value", &OwnsPythonObjects::value);
-}
+/*
+    tests/test_custom_type_setup.cpp -- Tests `pybind11::custom_type_setup`
+
+    Copyright (c) Google LLC
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/pybind11.h>
+
+#include "pybind11_tests.h"
+
+namespace py = pybind11;
+
+namespace {
+
+struct OwnsPythonObjects {
+    py::object value = py::none();
+};
+} // namespace
+
+TEST_SUBMODULE(custom_type_setup, m) {
+    py::class_<OwnsPythonObjects> cls(
+        m, "OwnsPythonObjects", py::custom_type_setup([](PyHeapTypeObject *heap_type) {
+            auto *type = &heap_type->ht_type;
+            type->tp_flags |= Py_TPFLAGS_HAVE_GC;
+            type->tp_traverse = [](PyObject *self_base, visitproc visit, void *arg) {
+                auto &self = py::cast<OwnsPythonObjects &>(py::handle(self_base));
+                Py_VISIT(self.value.ptr());
+                return 0;
+            };
+            type->tp_clear = [](PyObject *self_base) {
+                auto &self = py::cast<OwnsPythonObjects &>(py::handle(self_base));
+                self.value = py::none();
+                return 0;
+            };
+        }));
+    cls.def(py::init<>());
+    cls.def_readwrite("value", &OwnsPythonObjects::value);
+}

third_party/CityFlow/extern/pybind11/tests/test_custom_type_setup.py

@@ -1,48 +1,48 @@
-import gc
-import weakref
-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import custom_type_setup as m
-
-
-@pytest.fixture()
-def gc_tester():
-    """Tests that an object is garbage collected.
-
-    Assumes that any unreferenced objects are fully collected after calling
-    `gc.collect()`.  That is true on CPython, but does not appear to reliably
-    hold on PyPy.
-    """
-
-    weak_refs = []
-
-    def add_ref(obj):
-        # PyPy does not support `gc.is_tracked`.
-        if hasattr(gc, "is_tracked"):
-            assert gc.is_tracked(obj)
-        weak_refs.append(weakref.ref(obj))
-
-    yield add_ref
-
-    gc.collect()
-    for ref in weak_refs:
-        assert ref() is None
-
-
-# PyPy does not seem to reliably garbage collect.
-@pytest.mark.skipif("env.PYPY")
-def test_self_cycle(gc_tester):
-    obj = m.OwnsPythonObjects()
-    obj.value = obj
-    gc_tester(obj)
-
-
-# PyPy does not seem to reliably garbage collect.
-@pytest.mark.skipif("env.PYPY")
-def test_indirect_cycle(gc_tester):
-    obj = m.OwnsPythonObjects()
-    obj_list = [obj]
-    obj.value = obj_list
-    gc_tester(obj)
+import gc
+import weakref
+
+import pytest
+
+import env  # noqa: F401
+from pybind11_tests import custom_type_setup as m
+
+
+@pytest.fixture()
+def gc_tester():
+    """Tests that an object is garbage collected.
+
+    Assumes that any unreferenced objects are fully collected after calling
+    `gc.collect()`.  That is true on CPython, but does not appear to reliably
+    hold on PyPy.
+    """
+
+    weak_refs = []
+
+    def add_ref(obj):
+        # PyPy does not support `gc.is_tracked`.
+        if hasattr(gc, "is_tracked"):
+            assert gc.is_tracked(obj)
+        weak_refs.append(weakref.ref(obj))
+
+    yield add_ref
+
+    gc.collect()
+    for ref in weak_refs:
+        assert ref() is None
+
+
+# PyPy does not seem to reliably garbage collect.
+@pytest.mark.skipif("env.PYPY")
+def test_self_cycle(gc_tester):
+    obj = m.OwnsPythonObjects()
+    obj.value = obj
+    gc_tester(obj)
+
+
+# PyPy does not seem to reliably garbage collect.
+@pytest.mark.skipif("env.PYPY")
+def test_indirect_cycle(gc_tester):
+    obj = m.OwnsPythonObjects()
+    obj_list = [obj]
+    obj.value = obj_list
+    gc_tester(obj)

third_party/CityFlow/extern/pybind11/tests/test_docstring_options.cpp

@@ -1,141 +1,141 @@
-/*
-    tests/test_docstring_options.cpp -- generation of docstrings and signatures
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-TEST_SUBMODULE(docstring_options, m) {
-    // test_docstring_options
-    {
-        py::options options;
-        options.disable_function_signatures();
-
-        m.def(
-            "test_function1", [](int, int) {}, py::arg("a"), py::arg("b"));
-        m.def(
-            "test_function2", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
-        m.def(
-            "test_overloaded1", [](int) {}, py::arg("i"), "Overload docstring");
-        m.def(
-            "test_overloaded1", [](double) {}, py::arg("d"));
-
-        m.def(
-            "test_overloaded2", [](int) {}, py::arg("i"), "overload docstring 1");
-        m.def(
-            "test_overloaded2", [](double) {}, py::arg("d"), "overload docstring 2");
-
-        m.def(
-            "test_overloaded3", [](int) {}, py::arg("i"));
-        m.def(
-            "test_overloaded3", [](double) {}, py::arg("d"), "Overload docstr");
-
-        options.enable_function_signatures();
-
-        m.def(
-            "test_function3", [](int, int) {}, py::arg("a"), py::arg("b"));
-        m.def(
-            "test_function4", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
-        options.disable_function_signatures().disable_user_defined_docstrings();
-
-        m.def(
-            "test_function5", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
-        {
-            py::options nested_options;
-            nested_options.enable_user_defined_docstrings();
-            m.def(
-                "test_function6",
-                [](int, int) {},
-                py::arg("a"),
-                py::arg("b"),
-                "A custom docstring");
-        }
-    }
-
-    m.def(
-        "test_function7", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
-    {
-        py::options options;
-        options.disable_user_defined_docstrings();
-        options.disable_function_signatures();
-
-        m.def("test_function8", []() {});
-    }
-
-    {
-        py::options options;
-        options.disable_user_defined_docstrings();
-
-        struct DocstringTestFoo {
-            int value;
-            void setValue(int v) { value = v; }
-            int getValue() const { return value; }
-        };
-        py::class_<DocstringTestFoo>(m, "DocstringTestFoo", "This is a class docstring")
-            .def_property("value_prop",
-                          &DocstringTestFoo::getValue,
-                          &DocstringTestFoo::setValue,
-                          "This is a property docstring");
-    }
-
-    {
-        enum class DocstringTestEnum1 { Member1, Member2 };
-
-        py::enum_<DocstringTestEnum1>(m, "DocstringTestEnum1", "Enum docstring")
-            .value("Member1", DocstringTestEnum1::Member1)
-            .value("Member2", DocstringTestEnum1::Member2);
-    }
-
-    {
-        py::options options;
-        options.enable_enum_members_docstring();
-
-        enum class DocstringTestEnum2 { Member1, Member2 };
-
-        py::enum_<DocstringTestEnum2>(m, "DocstringTestEnum2", "Enum docstring")
-            .value("Member1", DocstringTestEnum2::Member1)
-            .value("Member2", DocstringTestEnum2::Member2);
-    }
-
-    {
-        py::options options;
-        options.disable_enum_members_docstring();
-
-        enum class DocstringTestEnum3 { Member1, Member2 };
-
-        py::enum_<DocstringTestEnum3>(m, "DocstringTestEnum3", "Enum docstring")
-            .value("Member1", DocstringTestEnum3::Member1)
-            .value("Member2", DocstringTestEnum3::Member2);
-    }
-
-    {
-        py::options options;
-        options.disable_user_defined_docstrings();
-
-        enum class DocstringTestEnum4 { Member1, Member2 };
-
-        py::enum_<DocstringTestEnum4>(m, "DocstringTestEnum4", "Enum docstring")
-            .value("Member1", DocstringTestEnum4::Member1)
-            .value("Member2", DocstringTestEnum4::Member2);
-    }
-
-    {
-        py::options options;
-        options.disable_user_defined_docstrings();
-        options.disable_enum_members_docstring();
-
-        enum class DocstringTestEnum5 { Member1, Member2 };
-
-        py::enum_<DocstringTestEnum5>(m, "DocstringTestEnum5", "Enum docstring")
-            .value("Member1", DocstringTestEnum5::Member1)
-            .value("Member2", DocstringTestEnum5::Member2);
-    }
-}
+/*
+    tests/test_docstring_options.cpp -- generation of docstrings and signatures
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "pybind11_tests.h"
+
+TEST_SUBMODULE(docstring_options, m) {
+    // test_docstring_options
+    {
+        py::options options;
+        options.disable_function_signatures();
+
+        m.def(
+            "test_function1", [](int, int) {}, py::arg("a"), py::arg("b"));
+        m.def(
+            "test_function2", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+
+        m.def(
+            "test_overloaded1", [](int) {}, py::arg("i"), "Overload docstring");
+        m.def(
+            "test_overloaded1", [](double) {}, py::arg("d"));
+
+        m.def(
+            "test_overloaded2", [](int) {}, py::arg("i"), "overload docstring 1");
+        m.def(
+            "test_overloaded2", [](double) {}, py::arg("d"), "overload docstring 2");
+
+        m.def(
+            "test_overloaded3", [](int) {}, py::arg("i"));
+        m.def(
+            "test_overloaded3", [](double) {}, py::arg("d"), "Overload docstr");
+
+        options.enable_function_signatures();
+
+        m.def(
+            "test_function3", [](int, int) {}, py::arg("a"), py::arg("b"));
+        m.def(
+            "test_function4", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+
+        options.disable_function_signatures().disable_user_defined_docstrings();
+
+        m.def(
+            "test_function5", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+
+        {
+            py::options nested_options;
+            nested_options.enable_user_defined_docstrings();
+            m.def(
+                "test_function6",
+                [](int, int) {},
+                py::arg("a"),
+                py::arg("b"),
+                "A custom docstring");
+        }
+    }
+
+    m.def(
+        "test_function7", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+
+    {
+        py::options options;
+        options.disable_user_defined_docstrings();
+        options.disable_function_signatures();
+
+        m.def("test_function8", []() {});
+    }
+
+    {
+        py::options options;
+        options.disable_user_defined_docstrings();
+
+        struct DocstringTestFoo {
+            int value;
+            void setValue(int v) { value = v; }
+            int getValue() const { return value; }
+        };
+        py::class_<DocstringTestFoo>(m, "DocstringTestFoo", "This is a class docstring")
+            .def_property("value_prop",
+                          &DocstringTestFoo::getValue,
+                          &DocstringTestFoo::setValue,
+                          "This is a property docstring");
+    }
+
+    {
+        enum class DocstringTestEnum1 { Member1, Member2 };
+
+        py::enum_<DocstringTestEnum1>(m, "DocstringTestEnum1", "Enum docstring")
+            .value("Member1", DocstringTestEnum1::Member1)
+            .value("Member2", DocstringTestEnum1::Member2);
+    }
+
+    {
+        py::options options;
+        options.enable_enum_members_docstring();
+
+        enum class DocstringTestEnum2 { Member1, Member2 };
+
+        py::enum_<DocstringTestEnum2>(m, "DocstringTestEnum2", "Enum docstring")
+            .value("Member1", DocstringTestEnum2::Member1)
+            .value("Member2", DocstringTestEnum2::Member2);
+    }
+
+    {
+        py::options options;
+        options.disable_enum_members_docstring();
+
+        enum class DocstringTestEnum3 { Member1, Member2 };
+
+        py::enum_<DocstringTestEnum3>(m, "DocstringTestEnum3", "Enum docstring")
+            .value("Member1", DocstringTestEnum3::Member1)
+            .value("Member2", DocstringTestEnum3::Member2);
+    }
+
+    {
+        py::options options;
+        options.disable_user_defined_docstrings();
+
+        enum class DocstringTestEnum4 { Member1, Member2 };
+
+        py::enum_<DocstringTestEnum4>(m, "DocstringTestEnum4", "Enum docstring")
+            .value("Member1", DocstringTestEnum4::Member1)
+            .value("Member2", DocstringTestEnum4::Member2);
+    }
+
+    {
+        py::options options;
+        options.disable_user_defined_docstrings();
+        options.disable_enum_members_docstring();
+
+        enum class DocstringTestEnum5 { Member1, Member2 };
+
+        py::enum_<DocstringTestEnum5>(m, "DocstringTestEnum5", "Enum docstring")
+            .value("Member1", DocstringTestEnum5::Member1)
+            .value("Member2", DocstringTestEnum5::Member2);
+    }
+}

third_party/CityFlow/extern/pybind11/tests/test_docstring_options.py

@@ -1,64 +1,64 @@
-from pybind11_tests import docstring_options as m
-
-
-def test_docstring_options():
-    # options.disable_function_signatures()
-    assert not m.test_function1.__doc__
-
-    assert m.test_function2.__doc__ == "A custom docstring"
-
-    # docstring specified on just the first overload definition:
-    assert m.test_overloaded1.__doc__ == "Overload docstring"
-
-    # docstring on both overloads:
-    assert m.test_overloaded2.__doc__ == "overload docstring 1\noverload docstring 2"
-
-    # docstring on only second overload:
-    assert m.test_overloaded3.__doc__ == "Overload docstr"
-
-    # options.enable_function_signatures()
-    assert m.test_function3.__doc__.startswith("test_function3(a: int, b: int) -> None")
-
-    assert m.test_function4.__doc__.startswith("test_function4(a: int, b: int) -> None")
-    assert m.test_function4.__doc__.endswith("A custom docstring\n")
-
-    # options.disable_function_signatures()
-    # options.disable_user_defined_docstrings()
-    assert not m.test_function5.__doc__
-
-    # nested options.enable_user_defined_docstrings()
-    assert m.test_function6.__doc__ == "A custom docstring"
-
-    # RAII destructor
-    assert m.test_function7.__doc__.startswith("test_function7(a: int, b: int) -> None")
-    assert m.test_function7.__doc__.endswith("A custom docstring\n")
-
-    # when all options are disabled, no docstring (instead of an empty one) should be generated
-    assert m.test_function8.__doc__ is None
-
-    # Suppression of user-defined docstrings for non-function objects
-    assert not m.DocstringTestFoo.__doc__
-    assert not m.DocstringTestFoo.value_prop.__doc__
-
-    # Check existig behaviour of enum docstings
-    assert (
-        m.DocstringTestEnum1.__doc__
-        == "Enum docstring\n\nMembers:\n\n  Member1\n\n  Member2"
-    )
-
-    # options.enable_enum_members_docstring()
-    assert (
-        m.DocstringTestEnum2.__doc__
-        == "Enum docstring\n\nMembers:\n\n  Member1\n\n  Member2"
-    )
-
-    # options.disable_enum_members_docstring()
-    assert m.DocstringTestEnum3.__doc__ == "Enum docstring"
-
-    # options.disable_user_defined_docstrings()
-    assert m.DocstringTestEnum4.__doc__ == "Members:\n\n  Member1\n\n  Member2"
-
-    # options.disable_user_defined_docstrings()
-    # options.disable_enum_members_docstring()
-    # When all options are disabled, no docstring (instead of an empty one) should be generated
-    assert m.DocstringTestEnum5.__doc__ is None
+from pybind11_tests import docstring_options as m
+
+
+def test_docstring_options():
+    # options.disable_function_signatures()
+    assert not m.test_function1.__doc__
+
+    assert m.test_function2.__doc__ == "A custom docstring"
+
+    # docstring specified on just the first overload definition:
+    assert m.test_overloaded1.__doc__ == "Overload docstring"
+
+    # docstring on both overloads:
+    assert m.test_overloaded2.__doc__ == "overload docstring 1\noverload docstring 2"
+
+    # docstring on only second overload:
+    assert m.test_overloaded3.__doc__ == "Overload docstr"
+
+    # options.enable_function_signatures()
+    assert m.test_function3.__doc__.startswith("test_function3(a: int, b: int) -> None")
+
+    assert m.test_function4.__doc__.startswith("test_function4(a: int, b: int) -> None")
+    assert m.test_function4.__doc__.endswith("A custom docstring\n")
+
+    # options.disable_function_signatures()
+    # options.disable_user_defined_docstrings()
+    assert not m.test_function5.__doc__
+
+    # nested options.enable_user_defined_docstrings()
+    assert m.test_function6.__doc__ == "A custom docstring"
+
+    # RAII destructor
+    assert m.test_function7.__doc__.startswith("test_function7(a: int, b: int) -> None")
+    assert m.test_function7.__doc__.endswith("A custom docstring\n")
+
+    # when all options are disabled, no docstring (instead of an empty one) should be generated
+    assert m.test_function8.__doc__ is None
+
+    # Suppression of user-defined docstrings for non-function objects
+    assert not m.DocstringTestFoo.__doc__
+    assert not m.DocstringTestFoo.value_prop.__doc__
+
+    # Check existig behaviour of enum docstings
+    assert (
+        m.DocstringTestEnum1.__doc__
+        == "Enum docstring\n\nMembers:\n\n  Member1\n\n  Member2"
+    )
+
+    # options.enable_enum_members_docstring()
+    assert (
+        m.DocstringTestEnum2.__doc__
+        == "Enum docstring\n\nMembers:\n\n  Member1\n\n  Member2"
+    )
+
+    # options.disable_enum_members_docstring()
+    assert m.DocstringTestEnum3.__doc__ == "Enum docstring"
+
+    # options.disable_user_defined_docstrings()
+    assert m.DocstringTestEnum4.__doc__ == "Members:\n\n  Member1\n\n  Member2"
+
+    # options.disable_user_defined_docstrings()
+    # options.disable_enum_members_docstring()
+    # When all options are disabled, no docstring (instead of an empty one) should be generated
+    assert m.DocstringTestEnum5.__doc__ is None

third_party/CityFlow/extern/pybind11/tests/test_eigen_matrix.cpp

@@ -1,445 +1,445 @@
-/*
-    tests/eigen.cpp -- automatic conversion of Eigen types
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/eigen/matrix.h>
-#include <pybind11/stl.h>
-
-#include "constructor_stats.h"
-#include "pybind11_tests.h"
-
-PYBIND11_WARNING_DISABLE_MSVC(4996)
-
-#include <Eigen/Cholesky>
-
-using MatrixXdR = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
-
-// Sets/resets a testing reference matrix to have values of 10*r + c, where r and c are the
-// (1-based) row/column number.
-template <typename M>
-void reset_ref(M &x) {
-    for (int i = 0; i < x.rows(); i++) {
-        for (int j = 0; j < x.cols(); j++) {
-            x(i, j) = 11 + 10 * i + j;
-        }
-    }
-}
-
-// Returns a static, column-major matrix
-Eigen::MatrixXd &get_cm() {
-    static Eigen::MatrixXd *x;
-    if (!x) {
-        x = new Eigen::MatrixXd(3, 3);
-        reset_ref(*x);
-    }
-    return *x;
-}
-// Likewise, but row-major
-MatrixXdR &get_rm() {
-    static MatrixXdR *x;
-    if (!x) {
-        x = new MatrixXdR(3, 3);
-        reset_ref(*x);
-    }
-    return *x;
-}
-// Resets the values of the static matrices returned by get_cm()/get_rm()
-void reset_refs() {
-    reset_ref(get_cm());
-    reset_ref(get_rm());
-}
-
-// Returns element 2,1 from a matrix (used to test copy/nocopy)
-double get_elem(const Eigen::Ref<const Eigen::MatrixXd> &m) { return m(2, 1); };
-
-// Returns a matrix with 10*r + 100*c added to each matrix element (to help test that the matrix
-// reference is referencing rows/columns correctly).
-template <typename MatrixArgType>
-Eigen::MatrixXd adjust_matrix(MatrixArgType m) {
-    Eigen::MatrixXd ret(m);
-    for (int c = 0; c < m.cols(); c++) {
-        for (int r = 0; r < m.rows(); r++) {
-            ret(r, c) += 10 * r + 100 * c; // NOLINT(clang-analyzer-core.uninitialized.Assign)
-        }
-    }
-    return ret;
-}
-
-struct CustomOperatorNew {
-    CustomOperatorNew() = default;
-
-    Eigen::Matrix4d a = Eigen::Matrix4d::Zero();
-    Eigen::Matrix4d b = Eigen::Matrix4d::Identity();
-
-    EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
-};
-
-TEST_SUBMODULE(eigen_matrix, m) {
-    using FixedMatrixR = Eigen::Matrix<float, 5, 6, Eigen::RowMajor>;
-    using FixedMatrixC = Eigen::Matrix<float, 5, 6>;
-    using DenseMatrixR = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
-    using DenseMatrixC = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>;
-    using FourRowMatrixC = Eigen::Matrix<float, 4, Eigen::Dynamic>;
-    using FourColMatrixC = Eigen::Matrix<float, Eigen::Dynamic, 4>;
-    using FourRowMatrixR = Eigen::Matrix<float, 4, Eigen::Dynamic>;
-    using FourColMatrixR = Eigen::Matrix<float, Eigen::Dynamic, 4>;
-    using SparseMatrixR = Eigen::SparseMatrix<float, Eigen::RowMajor>;
-    using SparseMatrixC = Eigen::SparseMatrix<float>;
-
-    // various tests
-    m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; });
-    m.def("double_row",
-          [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; });
-    m.def("double_complex",
-          [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; });
-    m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; });
-    m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; });
-    m.def("double_mat_cm", [](const Eigen::MatrixXf &x) -> Eigen::MatrixXf { return 2.0f * x; });
-    m.def("double_mat_rm", [](const DenseMatrixR &x) -> DenseMatrixR { return 2.0f * x; });
-
-    // test_eigen_ref_to_python
-    // Different ways of passing via Eigen::Ref; the first and second are the Eigen-recommended
-    m.def("cholesky1",
-          [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
-    m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd {
-        return x.llt().matrixL();
-    });
-    m.def("cholesky3",
-          [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
-    m.def("cholesky4", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd {
-        return x.llt().matrixL();
-    });
-
-    // test_eigen_ref_mutators
-    // Mutators: these add some value to the given element using Eigen, but Eigen should be mapping
-    // into the numpy array data and so the result should show up there.  There are three versions:
-    // one that works on a contiguous-row matrix (numpy's default), one for a contiguous-column
-    // matrix, and one for any matrix.
-    auto add_rm = [](Eigen::Ref<MatrixXdR> x, int r, int c, double v) { x(r, c) += v; };
-    auto add_cm = [](Eigen::Ref<Eigen::MatrixXd> x, int r, int c, double v) { x(r, c) += v; };
-
-    // Mutators (Eigen maps into numpy variables):
-    m.def("add_rm", add_rm); // Only takes row-contiguous
-    m.def("add_cm", add_cm); // Only takes column-contiguous
-    // Overloaded versions that will accept either row or column contiguous:
-    m.def("add1", add_rm);
-    m.def("add1", add_cm);
-    m.def("add2", add_cm);
-    m.def("add2", add_rm);
-    // This one accepts a matrix of any stride:
-    m.def("add_any",
-          [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r, c) += v; });
-
-    // Return mutable references (numpy maps into eigen variables)
-    m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); });
-    m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); });
-    // The same references, but non-mutable (numpy maps into eigen variables, but is !writeable)
-    m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); });
-    m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); });
-
-    m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values
-
-    // Increments and returns ref to (same) matrix
-    m.def(
-        "incr_matrix",
-        [](Eigen::Ref<Eigen::MatrixXd> m, double v) {
-            m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
-            return m;
-        },
-        py::return_value_policy::reference);
-
-    // Same, but accepts a matrix of any strides
-    m.def(
-        "incr_matrix_any",
-        [](py::EigenDRef<Eigen::MatrixXd> m, double v) {
-            m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
-            return m;
-        },
-        py::return_value_policy::reference);
-
-    // Returns an eigen slice of even rows
-    m.def(
-        "even_rows",
-        [](py::EigenDRef<Eigen::MatrixXd> m) {
-            return py::EigenDMap<Eigen::MatrixXd>(
-                m.data(),
-                (m.rows() + 1) / 2,
-                m.cols(),
-                py::EigenDStride(m.outerStride(), 2 * m.innerStride()));
-        },
-        py::return_value_policy::reference);
-
-    // Returns an eigen slice of even columns
-    m.def(
-        "even_cols",
-        [](py::EigenDRef<Eigen::MatrixXd> m) {
-            return py::EigenDMap<Eigen::MatrixXd>(
-                m.data(),
-                m.rows(),
-                (m.cols() + 1) / 2,
-                py::EigenDStride(2 * m.outerStride(), m.innerStride()));
-        },
-        py::return_value_policy::reference);
-
-    // Returns diagonals: a vector-like object with an inner stride != 1
-    m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); });
-    m.def("diagonal_1",
-          [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); });
-    m.def("diagonal_n",
-          [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); });
-
-    // Return a block of a matrix (gives non-standard strides)
-    m.def("block",
-          [m](const py::object &x_obj,
-              int start_row,
-              int start_col,
-              int block_rows,
-              int block_cols) {
-              return m.attr("_block")(x_obj, x_obj, start_row, start_col, block_rows, block_cols);
-          });
-
-    m.def(
-        "_block",
-        [](const py::object &x_obj,
-           const Eigen::Ref<const Eigen::MatrixXd> &x,
-           int start_row,
-           int start_col,
-           int block_rows,
-           int block_cols) {
-            // See PR #4217 for background. This test is a bit over the top, but might be useful
-            // as a concrete example to point to when explaining the dangling reference trap.
-            auto i0 = py::make_tuple(0, 0);
-            auto x0_orig = x_obj[*i0].cast<double>();
-            if (x(0, 0) != x0_orig) {
-                throw std::runtime_error(
-                    "Something in the type_caster for Eigen::Ref is terribly wrong.");
-            }
-            double x0_mod = x0_orig + 1;
-            x_obj[*i0] = x0_mod;
-            auto copy_detected = (x(0, 0) != x0_mod);
-            x_obj[*i0] = x0_orig;
-            if (copy_detected) {
-                throw std::runtime_error("type_caster for Eigen::Ref made a copy.");
-            }
-            return x.block(start_row, start_col, block_rows, block_cols);
-        },
-        py::keep_alive<0, 1>());
-
-    // test_eigen_return_references, test_eigen_keepalive
-    // return value referencing/copying tests:
-    class ReturnTester {
-        Eigen::MatrixXd mat = create();
-
-    public:
-        ReturnTester() { print_created(this); }
-        ~ReturnTester() { print_destroyed(this); }
-        static Eigen::MatrixXd create() { return Eigen::MatrixXd::Ones(10, 10); }
-        // NOLINTNEXTLINE(readability-const-return-type)
-        static const Eigen::MatrixXd createConst() { return Eigen::MatrixXd::Ones(10, 10); }
-        Eigen::MatrixXd &get() { return mat; }
-        Eigen::MatrixXd *getPtr() { return &mat; }
-        const Eigen::MatrixXd &view() { return mat; }
-        const Eigen::MatrixXd *viewPtr() { return &mat; }
-        Eigen::Ref<Eigen::MatrixXd> ref() { return mat; }
-        Eigen::Ref<const Eigen::MatrixXd> refConst() { return mat; }
-        Eigen::Block<Eigen::MatrixXd> block(int r, int c, int nrow, int ncol) {
-            return mat.block(r, c, nrow, ncol);
-        }
-        Eigen::Block<const Eigen::MatrixXd> blockConst(int r, int c, int nrow, int ncol) const {
-            return mat.block(r, c, nrow, ncol);
-        }
-        py::EigenDMap<Eigen::Matrix2d> corners() {
-            return py::EigenDMap<Eigen::Matrix2d>(
-                mat.data(),
-                py::EigenDStride(mat.outerStride() * (mat.outerSize() - 1),
-                                 mat.innerStride() * (mat.innerSize() - 1)));
-        }
-        py::EigenDMap<const Eigen::Matrix2d> cornersConst() const {
-            return py::EigenDMap<const Eigen::Matrix2d>(
-                mat.data(),
-                py::EigenDStride(mat.outerStride() * (mat.outerSize() - 1),
-                                 mat.innerStride() * (mat.innerSize() - 1)));
-        }
-    };
-    using rvp = py::return_value_policy;
-    py::class_<ReturnTester>(m, "ReturnTester")
-        .def(py::init<>())
-        .def_static("create", &ReturnTester::create)
-        .def_static("create_const", &ReturnTester::createConst)
-        .def("get", &ReturnTester::get, rvp::reference_internal)
-        .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal)
-        .def("view", &ReturnTester::view, rvp::reference_internal)
-        .def("view_ptr", &ReturnTester::view, rvp::reference_internal)
-        .def("copy_get", &ReturnTester::get)       // Default rvp: copy
-        .def("copy_view", &ReturnTester::view)     //         "
-        .def("ref", &ReturnTester::ref)            // Default for Ref is to reference
-        .def("ref_const", &ReturnTester::refConst) // Likewise, but const
-        .def("ref_safe", &ReturnTester::ref, rvp::reference_internal)
-        .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal)
-        .def("copy_ref", &ReturnTester::ref, rvp::copy)
-        .def("copy_ref_const", &ReturnTester::refConst, rvp::copy)
-        .def("block", &ReturnTester::block)
-        .def("block_safe", &ReturnTester::block, rvp::reference_internal)
-        .def("block_const", &ReturnTester::blockConst, rvp::reference_internal)
-        .def("copy_block", &ReturnTester::block, rvp::copy)
-        .def("corners", &ReturnTester::corners, rvp::reference_internal)
-        .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal);
-
-    // test_special_matrix_objects
-    // Returns a DiagonalMatrix with diagonal (1,2,3,...)
-    m.def("incr_diag", [](int k) {
-        Eigen::DiagonalMatrix<int, Eigen::Dynamic> m(k);
-        for (int i = 0; i < k; i++) {
-            m.diagonal()[i] = i + 1;
-        }
-        return m;
-    });
-
-    // Returns a SelfAdjointView referencing the lower triangle of m
-    m.def("symmetric_lower",
-          [](const Eigen::MatrixXi &m) { return m.selfadjointView<Eigen::Lower>(); });
-    // Returns a SelfAdjointView referencing the lower triangle of m
-    m.def("symmetric_upper",
-          [](const Eigen::MatrixXi &m) { return m.selfadjointView<Eigen::Upper>(); });
-
-    // Test matrix for various functions below.
-    Eigen::MatrixXf mat(5, 6);
-    mat << 0, 3, 0, 0, 0, 11, 22, 0, 0, 0, 17, 11, 7, 5, 0, 1, 0, 11, 0, 0, 0, 0, 0, 11, 0, 0, 14,
-        0, 8, 11;
-
-    // test_fixed, and various other tests
-    m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); });
-    // Our Eigen does a hack which respects constness through the numpy writeable flag.
-    // Therefore, the const return actually affects this type despite being an rvalue.
-    // NOLINTNEXTLINE(readability-const-return-type)
-    m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); });
-    m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); });
-    m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; });
-    m.def("fixed_copy_c", [](const FixedMatrixC &m) -> FixedMatrixC { return m; });
-    // test_mutator_descriptors
-    m.def("fixed_mutator_r", [](const Eigen::Ref<FixedMatrixR> &) {});
-    m.def("fixed_mutator_c", [](const Eigen::Ref<FixedMatrixC> &) {});
-    m.def("fixed_mutator_a", [](const py::EigenDRef<FixedMatrixC> &) {});
-    // test_dense
-    m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); });
-    m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); });
-    m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; });
-    m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; });
-    // test_defaults
-    bool have_numpy = true;
-    try {
-        py::module_::import("numpy");
-    } catch (const py::error_already_set &) {
-        have_numpy = false;
-    }
-    if (have_numpy) {
-        py::module_::import("numpy");
-        Eigen::Matrix<double, 3, 3> defaultMatrix = Eigen::Matrix3d::Identity();
-        m.def(
-            "defaults_mat", [](const Eigen::Matrix3d &) {}, py::arg("mat") = defaultMatrix);
-
-        Eigen::VectorXd defaultVector = Eigen::VectorXd::Ones(32);
-        m.def(
-            "defaults_vec", [](const Eigen::VectorXd &) {}, py::arg("vec") = defaultMatrix);
-    }
-    // test_sparse, test_sparse_signature
-    m.def("sparse_r", [mat]() -> SparseMatrixR {
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-        return Eigen::SparseView<Eigen::MatrixXf>(mat);
-    });
-    m.def("sparse_c",
-          [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
-    m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; });
-    m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; });
-    // test_partially_fixed
-    m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; });
-    m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; });
-    m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; });
-    m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; });
-
-    // test_cpp_casting
-    // Test that we can cast a numpy object to a Eigen::MatrixXd explicitly
-    m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); });
-    m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); });
-    m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); });
-    m.def("cpp_ref_any",
-          [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); });
-
-    // [workaround(intel)] ICC 20/21 breaks with py::arg().stuff, using py::arg{}.stuff works.
-
-    // test_nocopy_wrapper
-    // Test that we can prevent copying into an argument that would normally copy: First a version
-    // that would allow copying (if types or strides don't match) for comparison:
-    m.def("get_elem", &get_elem);
-    // Now this alternative that calls the tells pybind to fail rather than copy:
-    m.def(
-        "get_elem_nocopy",
-        [](const Eigen::Ref<const Eigen::MatrixXd> &m) -> double { return get_elem(m); },
-        py::arg{}.noconvert());
-    // Also test a row-major-only no-copy const ref:
-    m.def(
-        "get_elem_rm_nocopy",
-        [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long {
-            return m(2, 1);
-        },
-        py::arg{}.noconvert());
-
-    // test_issue738, test_zero_length
-    // Issue #738: 1×N or N×1 2D matrices were neither accepted nor properly copied with an
-    // incompatible stride value on the length-1 dimension--but that should be allowed (without
-    // requiring a copy!) because the stride value can be safely ignored on a size-1 dimension.
-    // Similarly, 0×N or N×0 matrices were not accepted--again, these should be allowed since
-    // they contain no data. This particularly affects numpy ≥ 1.23, which sets the strides to
-    // 0 if any dimension size is 0.
-    m.def("iss738_f1",
-          &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>,
-          py::arg{}.noconvert());
-    m.def("iss738_f2",
-          &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>,
-          py::arg{}.noconvert());
-
-    // test_issue1105
-    // Issue #1105: when converting from a numpy two-dimensional (Nx1) or (1xN) value into a dense
-    // eigen Vector or RowVector, the argument would fail to load because the numpy copy would
-    // fail: numpy won't broadcast a Nx1 into a 1-dimensional vector.
-    m.def("iss1105_col", [](const Eigen::VectorXd &) { return true; });
-    m.def("iss1105_row", [](const Eigen::RowVectorXd &) { return true; });
-
-    // test_named_arguments
-    // Make sure named arguments are working properly:
-    m.def(
-        "matrix_multiply",
-        [](const py::EigenDRef<const Eigen::MatrixXd> &A,
-           const py::EigenDRef<const Eigen::MatrixXd> &B) -> Eigen::MatrixXd {
-            if (A.cols() != B.rows()) {
-                throw std::domain_error("Nonconformable matrices!");
-            }
-            return A * B;
-        },
-        py::arg("A"),
-        py::arg("B"));
-
-    // test_custom_operator_new
-    py::class_<CustomOperatorNew>(m, "CustomOperatorNew")
-        .def(py::init<>())
-        .def_readonly("a", &CustomOperatorNew::a)
-        .def_readonly("b", &CustomOperatorNew::b);
-
-    // test_eigen_ref_life_support
-    // In case of a failure (the caster's temp array does not live long enough), creating
-    // a new array (np.ones(10)) increases the chances that the temp array will be garbage
-    // collected and/or that its memory will be overridden with different values.
-    m.def("get_elem_direct", [](const Eigen::Ref<const Eigen::VectorXd> &v) {
-        py::module_::import("numpy").attr("ones")(10);
-        return v(5);
-    });
-    m.def("get_elem_indirect", [](std::vector<Eigen::Ref<const Eigen::VectorXd>> v) {
-        py::module_::import("numpy").attr("ones")(10);
-        return v[0](5);
-    });
-}
+/*
+    tests/eigen.cpp -- automatic conversion of Eigen types
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/eigen/matrix.h>
+#include <pybind11/stl.h>
+
+#include "constructor_stats.h"
+#include "pybind11_tests.h"
+
+PYBIND11_WARNING_DISABLE_MSVC(4996)
+
+#include <Eigen/Cholesky>
+
+using MatrixXdR = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+
+// Sets/resets a testing reference matrix to have values of 10*r + c, where r and c are the
+// (1-based) row/column number.
+template <typename M>
+void reset_ref(M &x) {
+    for (int i = 0; i < x.rows(); i++) {
+        for (int j = 0; j < x.cols(); j++) {
+            x(i, j) = 11 + 10 * i + j;
+        }
+    }
+}
+
+// Returns a static, column-major matrix
+Eigen::MatrixXd &get_cm() {
+    static Eigen::MatrixXd *x;
+    if (!x) {
+        x = new Eigen::MatrixXd(3, 3);
+        reset_ref(*x);
+    }
+    return *x;
+}
+// Likewise, but row-major
+MatrixXdR &get_rm() {
+    static MatrixXdR *x;
+    if (!x) {
+        x = new MatrixXdR(3, 3);
+        reset_ref(*x);
+    }
+    return *x;
+}
+// Resets the values of the static matrices returned by get_cm()/get_rm()
+void reset_refs() {
+    reset_ref(get_cm());
+    reset_ref(get_rm());
+}
+
+// Returns element 2,1 from a matrix (used to test copy/nocopy)
+double get_elem(const Eigen::Ref<const Eigen::MatrixXd> &m) { return m(2, 1); };
+
+// Returns a matrix with 10*r + 100*c added to each matrix element (to help test that the matrix
+// reference is referencing rows/columns correctly).
+template <typename MatrixArgType>
+Eigen::MatrixXd adjust_matrix(MatrixArgType m) {
+    Eigen::MatrixXd ret(m);
+    for (int c = 0; c < m.cols(); c++) {
+        for (int r = 0; r < m.rows(); r++) {
+            ret(r, c) += 10 * r + 100 * c; // NOLINT(clang-analyzer-core.uninitialized.Assign)
+        }
+    }
+    return ret;
+}
+
+struct CustomOperatorNew {
+    CustomOperatorNew() = default;
+
+    Eigen::Matrix4d a = Eigen::Matrix4d::Zero();
+    Eigen::Matrix4d b = Eigen::Matrix4d::Identity();
+
+    EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
+};
+
+TEST_SUBMODULE(eigen_matrix, m) {
+    using FixedMatrixR = Eigen::Matrix<float, 5, 6, Eigen::RowMajor>;
+    using FixedMatrixC = Eigen::Matrix<float, 5, 6>;
+    using DenseMatrixR = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+    using DenseMatrixC = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>;
+    using FourRowMatrixC = Eigen::Matrix<float, 4, Eigen::Dynamic>;
+    using FourColMatrixC = Eigen::Matrix<float, Eigen::Dynamic, 4>;
+    using FourRowMatrixR = Eigen::Matrix<float, 4, Eigen::Dynamic>;
+    using FourColMatrixR = Eigen::Matrix<float, Eigen::Dynamic, 4>;
+    using SparseMatrixR = Eigen::SparseMatrix<float, Eigen::RowMajor>;
+    using SparseMatrixC = Eigen::SparseMatrix<float>;
+
+    // various tests
+    m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; });
+    m.def("double_row",
+          [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; });
+    m.def("double_complex",
+          [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; });
+    m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; });
+    m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; });
+    m.def("double_mat_cm", [](const Eigen::MatrixXf &x) -> Eigen::MatrixXf { return 2.0f * x; });
+    m.def("double_mat_rm", [](const DenseMatrixR &x) -> DenseMatrixR { return 2.0f * x; });
+
+    // test_eigen_ref_to_python
+    // Different ways of passing via Eigen::Ref; the first and second are the Eigen-recommended
+    m.def("cholesky1",
+          [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
+    m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd {
+        return x.llt().matrixL();
+    });
+    m.def("cholesky3",
+          [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
+    m.def("cholesky4", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd {
+        return x.llt().matrixL();
+    });
+
+    // test_eigen_ref_mutators
+    // Mutators: these add some value to the given element using Eigen, but Eigen should be mapping
+    // into the numpy array data and so the result should show up there.  There are three versions:
+    // one that works on a contiguous-row matrix (numpy's default), one for a contiguous-column
+    // matrix, and one for any matrix.
+    auto add_rm = [](Eigen::Ref<MatrixXdR> x, int r, int c, double v) { x(r, c) += v; };
+    auto add_cm = [](Eigen::Ref<Eigen::MatrixXd> x, int r, int c, double v) { x(r, c) += v; };
+
+    // Mutators (Eigen maps into numpy variables):
+    m.def("add_rm", add_rm); // Only takes row-contiguous
+    m.def("add_cm", add_cm); // Only takes column-contiguous
+    // Overloaded versions that will accept either row or column contiguous:
+    m.def("add1", add_rm);
+    m.def("add1", add_cm);
+    m.def("add2", add_cm);
+    m.def("add2", add_rm);
+    // This one accepts a matrix of any stride:
+    m.def("add_any",
+          [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r, c) += v; });
+
+    // Return mutable references (numpy maps into eigen variables)
+    m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); });
+    m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); });
+    // The same references, but non-mutable (numpy maps into eigen variables, but is !writeable)
+    m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); });
+    m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); });
+
+    m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values
+
+    // Increments and returns ref to (same) matrix
+    m.def(
+        "incr_matrix",
+        [](Eigen::Ref<Eigen::MatrixXd> m, double v) {
+            m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
+            return m;
+        },
+        py::return_value_policy::reference);
+
+    // Same, but accepts a matrix of any strides
+    m.def(
+        "incr_matrix_any",
+        [](py::EigenDRef<Eigen::MatrixXd> m, double v) {
+            m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
+            return m;
+        },
+        py::return_value_policy::reference);
+
+    // Returns an eigen slice of even rows
+    m.def(
+        "even_rows",
+        [](py::EigenDRef<Eigen::MatrixXd> m) {
+            return py::EigenDMap<Eigen::MatrixXd>(
+                m.data(),
+                (m.rows() + 1) / 2,
+                m.cols(),
+                py::EigenDStride(m.outerStride(), 2 * m.innerStride()));
+        },
+        py::return_value_policy::reference);
+
+    // Returns an eigen slice of even columns
+    m.def(
+        "even_cols",
+        [](py::EigenDRef<Eigen::MatrixXd> m) {
+            return py::EigenDMap<Eigen::MatrixXd>(
+                m.data(),
+                m.rows(),
+                (m.cols() + 1) / 2,
+                py::EigenDStride(2 * m.outerStride(), m.innerStride()));
+        },
+        py::return_value_policy::reference);
+
+    // Returns diagonals: a vector-like object with an inner stride != 1
+    m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); });
+    m.def("diagonal_1",
+          [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); });
+    m.def("diagonal_n",
+          [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); });
+
+    // Return a block of a matrix (gives non-standard strides)
+    m.def("block",
+          [m](const py::object &x_obj,
+              int start_row,
+              int start_col,
+              int block_rows,
+              int block_cols) {
+              return m.attr("_block")(x_obj, x_obj, start_row, start_col, block_rows, block_cols);
+          });
+
+    m.def(
+        "_block",
+        [](const py::object &x_obj,
+           const Eigen::Ref<const Eigen::MatrixXd> &x,
+           int start_row,
+           int start_col,
+           int block_rows,
+           int block_cols) {
+            // See PR #4217 for background. This test is a bit over the top, but might be useful
+            // as a concrete example to point to when explaining the dangling reference trap.
+            auto i0 = py::make_tuple(0, 0);
+            auto x0_orig = x_obj[*i0].cast<double>();
+            if (x(0, 0) != x0_orig) {
+                throw std::runtime_error(
+                    "Something in the type_caster for Eigen::Ref is terribly wrong.");
+            }
+            double x0_mod = x0_orig + 1;
+            x_obj[*i0] = x0_mod;
+            auto copy_detected = (x(0, 0) != x0_mod);
+            x_obj[*i0] = x0_orig;
+            if (copy_detected) {
+                throw std::runtime_error("type_caster for Eigen::Ref made a copy.");
+            }
+            return x.block(start_row, start_col, block_rows, block_cols);
+        },
+        py::keep_alive<0, 1>());
+
+    // test_eigen_return_references, test_eigen_keepalive
+    // return value referencing/copying tests:
+    class ReturnTester {
+        Eigen::MatrixXd mat = create();
+
+    public:
+        ReturnTester() { print_created(this); }
+        ~ReturnTester() { print_destroyed(this); }
+        static Eigen::MatrixXd create() { return Eigen::MatrixXd::Ones(10, 10); }
+        // NOLINTNEXTLINE(readability-const-return-type)
+        static const Eigen::MatrixXd createConst() { return Eigen::MatrixXd::Ones(10, 10); }
+        Eigen::MatrixXd &get() { return mat; }
+        Eigen::MatrixXd *getPtr() { return &mat; }
+        const Eigen::MatrixXd &view() { return mat; }
+        const Eigen::MatrixXd *viewPtr() { return &mat; }
+        Eigen::Ref<Eigen::MatrixXd> ref() { return mat; }
+        Eigen::Ref<const Eigen::MatrixXd> refConst() { return mat; }
+        Eigen::Block<Eigen::MatrixXd> block(int r, int c, int nrow, int ncol) {
+            return mat.block(r, c, nrow, ncol);
+        }
+        Eigen::Block<const Eigen::MatrixXd> blockConst(int r, int c, int nrow, int ncol) const {
+            return mat.block(r, c, nrow, ncol);
+        }
+        py::EigenDMap<Eigen::Matrix2d> corners() {
+            return py::EigenDMap<Eigen::Matrix2d>(
+                mat.data(),
+                py::EigenDStride(mat.outerStride() * (mat.outerSize() - 1),
+                                 mat.innerStride() * (mat.innerSize() - 1)));
+        }
+        py::EigenDMap<const Eigen::Matrix2d> cornersConst() const {
+            return py::EigenDMap<const Eigen::Matrix2d>(
+                mat.data(),
+                py::EigenDStride(mat.outerStride() * (mat.outerSize() - 1),
+                                 mat.innerStride() * (mat.innerSize() - 1)));
+        }
+    };
+    using rvp = py::return_value_policy;
+    py::class_<ReturnTester>(m, "ReturnTester")
+        .def(py::init<>())
+        .def_static("create", &ReturnTester::create)
+        .def_static("create_const", &ReturnTester::createConst)
+        .def("get", &ReturnTester::get, rvp::reference_internal)
+        .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal)
+        .def("view", &ReturnTester::view, rvp::reference_internal)
+        .def("view_ptr", &ReturnTester::view, rvp::reference_internal)
+        .def("copy_get", &ReturnTester::get)       // Default rvp: copy
+        .def("copy_view", &ReturnTester::view)     //         "
+        .def("ref", &ReturnTester::ref)            // Default for Ref is to reference
+        .def("ref_const", &ReturnTester::refConst) // Likewise, but const
+        .def("ref_safe", &ReturnTester::ref, rvp::reference_internal)
+        .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal)
+        .def("copy_ref", &ReturnTester::ref, rvp::copy)
+        .def("copy_ref_const", &ReturnTester::refConst, rvp::copy)
+        .def("block", &ReturnTester::block)
+        .def("block_safe", &ReturnTester::block, rvp::reference_internal)
+        .def("block_const", &ReturnTester::blockConst, rvp::reference_internal)
+        .def("copy_block", &ReturnTester::block, rvp::copy)
+        .def("corners", &ReturnTester::corners, rvp::reference_internal)
+        .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal);
+
+    // test_special_matrix_objects
+    // Returns a DiagonalMatrix with diagonal (1,2,3,...)
+    m.def("incr_diag", [](int k) {
+        Eigen::DiagonalMatrix<int, Eigen::Dynamic> m(k);
+        for (int i = 0; i < k; i++) {
+            m.diagonal()[i] = i + 1;
+        }
+        return m;
+    });
+
+    // Returns a SelfAdjointView referencing the lower triangle of m
+    m.def("symmetric_lower",
+          [](const Eigen::MatrixXi &m) { return m.selfadjointView<Eigen::Lower>(); });
+    // Returns a SelfAdjointView referencing the lower triangle of m
+    m.def("symmetric_upper",
+          [](const Eigen::MatrixXi &m) { return m.selfadjointView<Eigen::Upper>(); });
+
+    // Test matrix for various functions below.
+    Eigen::MatrixXf mat(5, 6);
+    mat << 0, 3, 0, 0, 0, 11, 22, 0, 0, 0, 17, 11, 7, 5, 0, 1, 0, 11, 0, 0, 0, 0, 0, 11, 0, 0, 14,
+        0, 8, 11;
+
+    // test_fixed, and various other tests
+    m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); });
+    // Our Eigen does a hack which respects constness through the numpy writeable flag.
+    // Therefore, the const return actually affects this type despite being an rvalue.
+    // NOLINTNEXTLINE(readability-const-return-type)
+    m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); });
+    m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); });
+    m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; });
+    m.def("fixed_copy_c", [](const FixedMatrixC &m) -> FixedMatrixC { return m; });
+    // test_mutator_descriptors
+    m.def("fixed_mutator_r", [](const Eigen::Ref<FixedMatrixR> &) {});
+    m.def("fixed_mutator_c", [](const Eigen::Ref<FixedMatrixC> &) {});
+    m.def("fixed_mutator_a", [](const py::EigenDRef<FixedMatrixC> &) {});
+    // test_dense
+    m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); });
+    m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); });
+    m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; });
+    m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; });
+    // test_defaults
+    bool have_numpy = true;
+    try {
+        py::module_::import("numpy");
+    } catch (const py::error_already_set &) {
+        have_numpy = false;
+    }
+    if (have_numpy) {
+        py::module_::import("numpy");
+        Eigen::Matrix<double, 3, 3> defaultMatrix = Eigen::Matrix3d::Identity();
+        m.def(
+            "defaults_mat", [](const Eigen::Matrix3d &) {}, py::arg("mat") = defaultMatrix);
+
+        Eigen::VectorXd defaultVector = Eigen::VectorXd::Ones(32);
+        m.def(
+            "defaults_vec", [](const Eigen::VectorXd &) {}, py::arg("vec") = defaultMatrix);
+    }
+    // test_sparse, test_sparse_signature
+    m.def("sparse_r", [mat]() -> SparseMatrixR {
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return Eigen::SparseView<Eigen::MatrixXf>(mat);
+    });
+    m.def("sparse_c",
+          [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
+    m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; });
+    m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; });
+    // test_partially_fixed
+    m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; });
+    m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; });
+    m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; });
+    m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; });
+
+    // test_cpp_casting
+    // Test that we can cast a numpy object to a Eigen::MatrixXd explicitly
+    m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); });
+    m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); });
+    m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); });
+    m.def("cpp_ref_any",
+          [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); });
+
+    // [workaround(intel)] ICC 20/21 breaks with py::arg().stuff, using py::arg{}.stuff works.
+
+    // test_nocopy_wrapper
+    // Test that we can prevent copying into an argument that would normally copy: First a version
+    // that would allow copying (if types or strides don't match) for comparison:
+    m.def("get_elem", &get_elem);
+    // Now this alternative that calls the tells pybind to fail rather than copy:
+    m.def(
+        "get_elem_nocopy",
+        [](const Eigen::Ref<const Eigen::MatrixXd> &m) -> double { return get_elem(m); },
+        py::arg{}.noconvert());
+    // Also test a row-major-only no-copy const ref:
+    m.def(
+        "get_elem_rm_nocopy",
+        [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long {
+            return m(2, 1);
+        },
+        py::arg{}.noconvert());
+
+    // test_issue738, test_zero_length
+    // Issue #738: 1×N or N×1 2D matrices were neither accepted nor properly copied with an
+    // incompatible stride value on the length-1 dimension--but that should be allowed (without
+    // requiring a copy!) because the stride value can be safely ignored on a size-1 dimension.
+    // Similarly, 0×N or N×0 matrices were not accepted--again, these should be allowed since
+    // they contain no data. This particularly affects numpy ≥ 1.23, which sets the strides to
+    // 0 if any dimension size is 0.
+    m.def("iss738_f1",
+          &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>,
+          py::arg{}.noconvert());
+    m.def("iss738_f2",
+          &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>,
+          py::arg{}.noconvert());
+
+    // test_issue1105
+    // Issue #1105: when converting from a numpy two-dimensional (Nx1) or (1xN) value into a dense
+    // eigen Vector or RowVector, the argument would fail to load because the numpy copy would
+    // fail: numpy won't broadcast a Nx1 into a 1-dimensional vector.
+    m.def("iss1105_col", [](const Eigen::VectorXd &) { return true; });
+    m.def("iss1105_row", [](const Eigen::RowVectorXd &) { return true; });
+
+    // test_named_arguments
+    // Make sure named arguments are working properly:
+    m.def(
+        "matrix_multiply",
+        [](const py::EigenDRef<const Eigen::MatrixXd> &A,
+           const py::EigenDRef<const Eigen::MatrixXd> &B) -> Eigen::MatrixXd {
+            if (A.cols() != B.rows()) {
+                throw std::domain_error("Nonconformable matrices!");
+            }
+            return A * B;
+        },
+        py::arg("A"),
+        py::arg("B"));
+
+    // test_custom_operator_new
+    py::class_<CustomOperatorNew>(m, "CustomOperatorNew")
+        .def(py::init<>())
+        .def_readonly("a", &CustomOperatorNew::a)
+        .def_readonly("b", &CustomOperatorNew::b);
+
+    // test_eigen_ref_life_support
+    // In case of a failure (the caster's temp array does not live long enough), creating
+    // a new array (np.ones(10)) increases the chances that the temp array will be garbage
+    // collected and/or that its memory will be overridden with different values.
+    m.def("get_elem_direct", [](const Eigen::Ref<const Eigen::VectorXd> &v) {
+        py::module_::import("numpy").attr("ones")(10);
+        return v(5);
+    });
+    m.def("get_elem_indirect", [](std::vector<Eigen::Ref<const Eigen::VectorXd>> v) {
+        py::module_::import("numpy").attr("ones")(10);
+        return v[0](5);
+    });
+}

third_party/CityFlow/extern/pybind11/tests/test_eigen_matrix.py

@@ -1,814 +1,814 @@
-import pytest
-
-from pybind11_tests import ConstructorStats
-
-np = pytest.importorskip("numpy")
-m = pytest.importorskip("pybind11_tests.eigen_matrix")
-
-
-ref = np.array(
-    [
-        [0.0, 3, 0, 0, 0, 11],
-        [22, 0, 0, 0, 17, 11],
-        [7, 5, 0, 1, 0, 11],
-        [0, 0, 0, 0, 0, 11],
-        [0, 0, 14, 0, 8, 11],
-    ]
-)
-
-
-def assert_equal_ref(mat):
-    np.testing.assert_array_equal(mat, ref)
-
-
-def assert_sparse_equal_ref(sparse_mat):
-    assert_equal_ref(sparse_mat.toarray())
-
-
-def test_fixed():
-    assert_equal_ref(m.fixed_c())
-    assert_equal_ref(m.fixed_r())
-    assert_equal_ref(m.fixed_copy_r(m.fixed_r()))
-    assert_equal_ref(m.fixed_copy_c(m.fixed_c()))
-    assert_equal_ref(m.fixed_copy_r(m.fixed_c()))
-    assert_equal_ref(m.fixed_copy_c(m.fixed_r()))
-
-
-def test_dense():
-    assert_equal_ref(m.dense_r())
-    assert_equal_ref(m.dense_c())
-    assert_equal_ref(m.dense_copy_r(m.dense_r()))
-    assert_equal_ref(m.dense_copy_c(m.dense_c()))
-    assert_equal_ref(m.dense_copy_r(m.dense_c()))
-    assert_equal_ref(m.dense_copy_c(m.dense_r()))
-
-
-def test_partially_fixed():
-    ref2 = np.array([[0.0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]])
-    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2[:, 1]), ref2[:, [1]])
-    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2[0, :]), ref2[[0], :])
-    np.testing.assert_array_equal(
-        m.partial_copy_four_rm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)]
-    )
-    np.testing.assert_array_equal(
-        m.partial_copy_four_rm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :]
-    )
-
-    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2), ref2)
-    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2[:, 1]), ref2[:, [1]])
-    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2[0, :]), ref2[[0], :])
-    np.testing.assert_array_equal(
-        m.partial_copy_four_cm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)]
-    )
-    np.testing.assert_array_equal(
-        m.partial_copy_four_cm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :]
-    )
-
-    # TypeError should be raise for a shape mismatch
-    functions = [
-        m.partial_copy_four_rm_r,
-        m.partial_copy_four_rm_c,
-        m.partial_copy_four_cm_r,
-        m.partial_copy_four_cm_c,
-    ]
-    matrix_with_wrong_shape = [[1, 2], [3, 4]]
-    for f in functions:
-        with pytest.raises(TypeError) as excinfo:
-            f(matrix_with_wrong_shape)
-        assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test_mutator_descriptors():
-    zr = np.arange(30, dtype="float32").reshape(5, 6)  # row-major
-    zc = zr.reshape(6, 5).transpose()  # column-major
-
-    m.fixed_mutator_r(zr)
-    m.fixed_mutator_c(zc)
-    m.fixed_mutator_a(zr)
-    m.fixed_mutator_a(zc)
-    with pytest.raises(TypeError) as excinfo:
-        m.fixed_mutator_r(zc)
-    assert (
-        "(arg0: numpy.ndarray[numpy.float32[5, 6],"
-        " flags.writeable, flags.c_contiguous]) -> None" in str(excinfo.value)
-    )
-    with pytest.raises(TypeError) as excinfo:
-        m.fixed_mutator_c(zr)
-    assert (
-        "(arg0: numpy.ndarray[numpy.float32[5, 6],"
-        " flags.writeable, flags.f_contiguous]) -> None" in str(excinfo.value)
-    )
-    with pytest.raises(TypeError) as excinfo:
-        m.fixed_mutator_a(np.array([[1, 2], [3, 4]], dtype="float32"))
-    assert "(arg0: numpy.ndarray[numpy.float32[5, 6], flags.writeable]) -> None" in str(
-        excinfo.value
-    )
-    zr.flags.writeable = False
-    with pytest.raises(TypeError):
-        m.fixed_mutator_r(zr)
-    with pytest.raises(TypeError):
-        m.fixed_mutator_a(zr)
-
-
-def test_cpp_casting():
-    assert m.cpp_copy(m.fixed_r()) == 22.0
-    assert m.cpp_copy(m.fixed_c()) == 22.0
-    z = np.array([[5.0, 6], [7, 8]])
-    assert m.cpp_copy(z) == 7.0
-    assert m.cpp_copy(m.get_cm_ref()) == 21.0
-    assert m.cpp_copy(m.get_rm_ref()) == 21.0
-    assert m.cpp_ref_c(m.get_cm_ref()) == 21.0
-    assert m.cpp_ref_r(m.get_rm_ref()) == 21.0
-    with pytest.raises(RuntimeError) as excinfo:
-        # Can't reference m.fixed_c: it contains floats, m.cpp_ref_any wants doubles
-        m.cpp_ref_any(m.fixed_c())
-    assert "Unable to cast Python instance" in str(excinfo.value)
-    with pytest.raises(RuntimeError) as excinfo:
-        # Can't reference m.fixed_r: it contains floats, m.cpp_ref_any wants doubles
-        m.cpp_ref_any(m.fixed_r())
-    assert "Unable to cast Python instance" in str(excinfo.value)
-    assert m.cpp_ref_any(m.ReturnTester.create()) == 1.0
-
-    assert m.cpp_ref_any(m.get_cm_ref()) == 21.0
-    assert m.cpp_ref_any(m.get_cm_ref()) == 21.0
-
-
-def test_pass_readonly_array():
-    z = np.full((5, 6), 42.0)
-    z.flags.writeable = False
-    np.testing.assert_array_equal(z, m.fixed_copy_r(z))
-    np.testing.assert_array_equal(m.fixed_r_const(), m.fixed_r())
-    assert not m.fixed_r_const().flags.writeable
-    np.testing.assert_array_equal(m.fixed_copy_r(m.fixed_r_const()), m.fixed_r_const())
-
-
-def test_nonunit_stride_from_python():
-    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
-    second_row = counting_mat[1, :]
-    second_col = counting_mat[:, 1]
-    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
-
-    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
-    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
-    for ref_mat in slices:
-        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
-        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
-
-    # Mutator:
-    m.double_threer(second_row)
-    m.double_threec(second_col)
-    np.testing.assert_array_equal(counting_mat, [[0.0, 2, 2], [6, 16, 10], [6, 14, 8]])
-
-
-def test_negative_stride_from_python(msg):
-    """Eigen doesn't support (as of yet) negative strides. When a function takes an Eigen matrix by
-    copy or const reference, we can pass a numpy array that has negative strides.  Otherwise, an
-    exception will be thrown as Eigen will not be able to map the numpy array."""
-
-    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
-    counting_mat = counting_mat[::-1, ::-1]
-    second_row = counting_mat[1, :]
-    second_col = counting_mat[:, 1]
-    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
-    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
-    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
-
-    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
-    counting_3d = counting_3d[::-1, ::-1, ::-1]
-    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
-    for ref_mat in slices:
-        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
-        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
-
-    # Mutator:
-    with pytest.raises(TypeError) as excinfo:
-        m.double_threer(second_row)
-    assert (
-        msg(excinfo.value)
-        == """
-        double_threer(): incompatible function arguments. The following argument types are supported:
-            1. (arg0: numpy.ndarray[numpy.float32[1, 3], flags.writeable]) -> None
-
-        Invoked with: """
-        + repr(np.array([5.0, 4.0, 3.0], dtype="float32"))
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        m.double_threec(second_col)
-    assert (
-        msg(excinfo.value)
-        == """
-        double_threec(): incompatible function arguments. The following argument types are supported:
-            1. (arg0: numpy.ndarray[numpy.float32[3, 1], flags.writeable]) -> None
-
-        Invoked with: """
-        + repr(np.array([7.0, 4.0, 1.0], dtype="float32"))
-    )
-
-
-def test_block_runtime_error_type_caster_eigen_ref_made_a_copy():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.block(ref, 0, 0, 0, 0)
-    assert str(excinfo.value) == "type_caster for Eigen::Ref made a copy."
-
-
-def test_nonunit_stride_to_python():
-    assert np.all(m.diagonal(ref) == ref.diagonal())
-    assert np.all(m.diagonal_1(ref) == ref.diagonal(1))
-    for i in range(-5, 7):
-        assert np.all(m.diagonal_n(ref, i) == ref.diagonal(i)), f"m.diagonal_n({i})"
-
-    # Must be order="F", otherwise the type_caster will make a copy and
-    # m.block() will return a dangling reference (heap-use-after-free).
-    rof = np.asarray(ref, order="F")
-    assert np.all(m.block(rof, 2, 1, 3, 3) == rof[2:5, 1:4])
-    assert np.all(m.block(rof, 1, 4, 4, 2) == rof[1:, 4:])
-    assert np.all(m.block(rof, 1, 4, 3, 2) == rof[1:4, 4:])
-
-
-def test_eigen_ref_to_python():
-    chols = [m.cholesky1, m.cholesky2, m.cholesky3, m.cholesky4]
-    for i, chol in enumerate(chols, start=1):
-        mymat = chol(np.array([[1.0, 2, 4], [2, 13, 23], [4, 23, 77]]))
-        assert np.all(
-            mymat == np.array([[1, 0, 0], [2, 3, 0], [4, 5, 6]])
-        ), f"cholesky{i}"
-
-
-def assign_both(a1, a2, r, c, v):
-    a1[r, c] = v
-    a2[r, c] = v
-
-
-def array_copy_but_one(a, r, c, v):
-    z = np.array(a, copy=True)
-    z[r, c] = v
-    return z
-
-
-def test_eigen_return_references():
-    """Tests various ways of returning references and non-referencing copies"""
-
-    primary = np.ones((10, 10))
-    a = m.ReturnTester()
-    a_get1 = a.get()
-    assert not a_get1.flags.owndata
-    assert a_get1.flags.writeable
-    assign_both(a_get1, primary, 3, 3, 5)
-    a_get2 = a.get_ptr()
-    assert not a_get2.flags.owndata
-    assert a_get2.flags.writeable
-    assign_both(a_get1, primary, 2, 3, 6)
-
-    a_view1 = a.view()
-    assert not a_view1.flags.owndata
-    assert not a_view1.flags.writeable
-    with pytest.raises(ValueError):
-        a_view1[2, 3] = 4
-    a_view2 = a.view_ptr()
-    assert not a_view2.flags.owndata
-    assert not a_view2.flags.writeable
-    with pytest.raises(ValueError):
-        a_view2[2, 3] = 4
-
-    a_copy1 = a.copy_get()
-    assert a_copy1.flags.owndata
-    assert a_copy1.flags.writeable
-    np.testing.assert_array_equal(a_copy1, primary)
-    a_copy1[7, 7] = -44  # Shouldn't affect anything else
-    c1want = array_copy_but_one(primary, 7, 7, -44)
-    a_copy2 = a.copy_view()
-    assert a_copy2.flags.owndata
-    assert a_copy2.flags.writeable
-    np.testing.assert_array_equal(a_copy2, primary)
-    a_copy2[4, 4] = -22  # Shouldn't affect anything else
-    c2want = array_copy_but_one(primary, 4, 4, -22)
-
-    a_ref1 = a.ref()
-    assert not a_ref1.flags.owndata
-    assert a_ref1.flags.writeable
-    assign_both(a_ref1, primary, 1, 1, 15)
-    a_ref2 = a.ref_const()
-    assert not a_ref2.flags.owndata
-    assert not a_ref2.flags.writeable
-    with pytest.raises(ValueError):
-        a_ref2[5, 5] = 33
-    a_ref3 = a.ref_safe()
-    assert not a_ref3.flags.owndata
-    assert a_ref3.flags.writeable
-    assign_both(a_ref3, primary, 0, 7, 99)
-    a_ref4 = a.ref_const_safe()
-    assert not a_ref4.flags.owndata
-    assert not a_ref4.flags.writeable
-    with pytest.raises(ValueError):
-        a_ref4[7, 0] = 987654321
-
-    a_copy3 = a.copy_ref()
-    assert a_copy3.flags.owndata
-    assert a_copy3.flags.writeable
-    np.testing.assert_array_equal(a_copy3, primary)
-    a_copy3[8, 1] = 11
-    c3want = array_copy_but_one(primary, 8, 1, 11)
-    a_copy4 = a.copy_ref_const()
-    assert a_copy4.flags.owndata
-    assert a_copy4.flags.writeable
-    np.testing.assert_array_equal(a_copy4, primary)
-    a_copy4[8, 4] = 88
-    c4want = array_copy_but_one(primary, 8, 4, 88)
-
-    a_block1 = a.block(3, 3, 2, 2)
-    assert not a_block1.flags.owndata
-    assert a_block1.flags.writeable
-    a_block1[0, 0] = 55
-    primary[3, 3] = 55
-    a_block2 = a.block_safe(2, 2, 3, 2)
-    assert not a_block2.flags.owndata
-    assert a_block2.flags.writeable
-    a_block2[2, 1] = -123
-    primary[4, 3] = -123
-    a_block3 = a.block_const(6, 7, 4, 3)
-    assert not a_block3.flags.owndata
-    assert not a_block3.flags.writeable
-    with pytest.raises(ValueError):
-        a_block3[2, 2] = -44444
-
-    a_copy5 = a.copy_block(2, 2, 2, 3)
-    assert a_copy5.flags.owndata
-    assert a_copy5.flags.writeable
-    np.testing.assert_array_equal(a_copy5, primary[2:4, 2:5])
-    a_copy5[1, 1] = 777
-    c5want = array_copy_but_one(primary[2:4, 2:5], 1, 1, 777)
-
-    a_corn1 = a.corners()
-    assert not a_corn1.flags.owndata
-    assert a_corn1.flags.writeable
-    a_corn1 *= 50
-    a_corn1[1, 1] = 999
-    primary[0, 0] = 50
-    primary[0, 9] = 50
-    primary[9, 0] = 50
-    primary[9, 9] = 999
-    a_corn2 = a.corners_const()
-    assert not a_corn2.flags.owndata
-    assert not a_corn2.flags.writeable
-    with pytest.raises(ValueError):
-        a_corn2[1, 0] = 51
-
-    # All of the changes made all the way along should be visible everywhere
-    # now (except for the copies, of course)
-    np.testing.assert_array_equal(a_get1, primary)
-    np.testing.assert_array_equal(a_get2, primary)
-    np.testing.assert_array_equal(a_view1, primary)
-    np.testing.assert_array_equal(a_view2, primary)
-    np.testing.assert_array_equal(a_ref1, primary)
-    np.testing.assert_array_equal(a_ref2, primary)
-    np.testing.assert_array_equal(a_ref3, primary)
-    np.testing.assert_array_equal(a_ref4, primary)
-    np.testing.assert_array_equal(a_block1, primary[3:5, 3:5])
-    np.testing.assert_array_equal(a_block2, primary[2:5, 2:4])
-    np.testing.assert_array_equal(a_block3, primary[6:10, 7:10])
-    np.testing.assert_array_equal(
-        a_corn1, primary[0 :: primary.shape[0] - 1, 0 :: primary.shape[1] - 1]
-    )
-    np.testing.assert_array_equal(
-        a_corn2, primary[0 :: primary.shape[0] - 1, 0 :: primary.shape[1] - 1]
-    )
-
-    np.testing.assert_array_equal(a_copy1, c1want)
-    np.testing.assert_array_equal(a_copy2, c2want)
-    np.testing.assert_array_equal(a_copy3, c3want)
-    np.testing.assert_array_equal(a_copy4, c4want)
-    np.testing.assert_array_equal(a_copy5, c5want)
-
-
-def assert_keeps_alive(cl, method, *args):
-    cstats = ConstructorStats.get(cl)
-    start_with = cstats.alive()
-    a = cl()
-    assert cstats.alive() == start_with + 1
-    z = method(a, *args)
-    assert cstats.alive() == start_with + 1
-    del a
-    # Here's the keep alive in action:
-    assert cstats.alive() == start_with + 1
-    del z
-    # Keep alive should have expired:
-    assert cstats.alive() == start_with
-
-
-def test_eigen_keepalive():
-    a = m.ReturnTester()
-    cstats = ConstructorStats.get(m.ReturnTester)
-    assert cstats.alive() == 1
-    unsafe = [a.ref(), a.ref_const(), a.block(1, 2, 3, 4)]
-    copies = [
-        a.copy_get(),
-        a.copy_view(),
-        a.copy_ref(),
-        a.copy_ref_const(),
-        a.copy_block(4, 3, 2, 1),
-    ]
-    del a
-    assert cstats.alive() == 0
-    del unsafe
-    del copies
-
-    for meth in [
-        m.ReturnTester.get,
-        m.ReturnTester.get_ptr,
-        m.ReturnTester.view,
-        m.ReturnTester.view_ptr,
-        m.ReturnTester.ref_safe,
-        m.ReturnTester.ref_const_safe,
-        m.ReturnTester.corners,
-        m.ReturnTester.corners_const,
-    ]:
-        assert_keeps_alive(m.ReturnTester, meth)
-
-    for meth in [m.ReturnTester.block_safe, m.ReturnTester.block_const]:
-        assert_keeps_alive(m.ReturnTester, meth, 4, 3, 2, 1)
-
-
-def test_eigen_ref_mutators():
-    """Tests Eigen's ability to mutate numpy values"""
-
-    orig = np.array([[1.0, 2, 3], [4, 5, 6], [7, 8, 9]])
-    zr = np.array(orig)
-    zc = np.array(orig, order="F")
-    m.add_rm(zr, 1, 0, 100)
-    assert np.all(zr == np.array([[1.0, 2, 3], [104, 5, 6], [7, 8, 9]]))
-    m.add_cm(zc, 1, 0, 200)
-    assert np.all(zc == np.array([[1.0, 2, 3], [204, 5, 6], [7, 8, 9]]))
-
-    m.add_any(zr, 1, 0, 20)
-    assert np.all(zr == np.array([[1.0, 2, 3], [124, 5, 6], [7, 8, 9]]))
-    m.add_any(zc, 1, 0, 10)
-    assert np.all(zc == np.array([[1.0, 2, 3], [214, 5, 6], [7, 8, 9]]))
-
-    # Can't reference a col-major array with a row-major Ref, and vice versa:
-    with pytest.raises(TypeError):
-        m.add_rm(zc, 1, 0, 1)
-    with pytest.raises(TypeError):
-        m.add_cm(zr, 1, 0, 1)
-
-    # Overloads:
-    m.add1(zr, 1, 0, -100)
-    m.add2(zr, 1, 0, -20)
-    assert np.all(zr == orig)
-    m.add1(zc, 1, 0, -200)
-    m.add2(zc, 1, 0, -10)
-    assert np.all(zc == orig)
-
-    # a non-contiguous slice (this won't work on either the row- or
-    # column-contiguous refs, but should work for the any)
-    cornersr = zr[0::2, 0::2]
-    cornersc = zc[0::2, 0::2]
-
-    assert np.all(cornersr == np.array([[1.0, 3], [7, 9]]))
-    assert np.all(cornersc == np.array([[1.0, 3], [7, 9]]))
-
-    with pytest.raises(TypeError):
-        m.add_rm(cornersr, 0, 1, 25)
-    with pytest.raises(TypeError):
-        m.add_cm(cornersr, 0, 1, 25)
-    with pytest.raises(TypeError):
-        m.add_rm(cornersc, 0, 1, 25)
-    with pytest.raises(TypeError):
-        m.add_cm(cornersc, 0, 1, 25)
-    m.add_any(cornersr, 0, 1, 25)
-    m.add_any(cornersc, 0, 1, 44)
-    assert np.all(zr == np.array([[1.0, 2, 28], [4, 5, 6], [7, 8, 9]]))
-    assert np.all(zc == np.array([[1.0, 2, 47], [4, 5, 6], [7, 8, 9]]))
-
-    # You shouldn't be allowed to pass a non-writeable array to a mutating Eigen method:
-    zro = zr[0:4, 0:4]
-    zro.flags.writeable = False
-    with pytest.raises(TypeError):
-        m.add_rm(zro, 0, 0, 0)
-    with pytest.raises(TypeError):
-        m.add_any(zro, 0, 0, 0)
-    with pytest.raises(TypeError):
-        m.add1(zro, 0, 0, 0)
-    with pytest.raises(TypeError):
-        m.add2(zro, 0, 0, 0)
-
-    # integer array shouldn't be passable to a double-matrix-accepting mutating func:
-    zi = np.array([[1, 2], [3, 4]])
-    with pytest.raises(TypeError):
-        m.add_rm(zi)
-
-
-def test_numpy_ref_mutators():
-    """Tests numpy mutating Eigen matrices (for returned Eigen::Ref<...>s)"""
-
-    m.reset_refs()  # In case another test already changed it
-
-    zc = m.get_cm_ref()
-    zcro = m.get_cm_const_ref()
-    zr = m.get_rm_ref()
-    zrro = m.get_rm_const_ref()
-
-    assert [zc[1, 2], zcro[1, 2], zr[1, 2], zrro[1, 2]] == [23] * 4
-
-    assert not zc.flags.owndata
-    assert zc.flags.writeable
-    assert not zr.flags.owndata
-    assert zr.flags.writeable
-    assert not zcro.flags.owndata
-    assert not zcro.flags.writeable
-    assert not zrro.flags.owndata
-    assert not zrro.flags.writeable
-
-    zc[1, 2] = 99
-    expect = np.array([[11.0, 12, 13], [21, 22, 99], [31, 32, 33]])
-    # We should have just changed zc, of course, but also zcro and the original eigen matrix
-    assert np.all(zc == expect)
-    assert np.all(zcro == expect)
-    assert np.all(m.get_cm_ref() == expect)
-
-    zr[1, 2] = 99
-    assert np.all(zr == expect)
-    assert np.all(zrro == expect)
-    assert np.all(m.get_rm_ref() == expect)
-
-    # Make sure the readonly ones are numpy-readonly:
-    with pytest.raises(ValueError):
-        zcro[1, 2] = 6
-    with pytest.raises(ValueError):
-        zrro[1, 2] = 6
-
-    # We should be able to explicitly copy like this (and since we're copying,
-    # the const should drop away)
-    y1 = np.array(m.get_cm_const_ref())
-
-    assert y1.flags.owndata
-    assert y1.flags.writeable
-    # We should get copies of the eigen data, which was modified above:
-    assert y1[1, 2] == 99
-    y1[1, 2] += 12
-    assert y1[1, 2] == 111
-    assert zc[1, 2] == 99  # Make sure we aren't referencing the original
-
-
-def test_both_ref_mutators():
-    """Tests a complex chain of nested eigen/numpy references"""
-
-    m.reset_refs()  # In case another test already changed it
-
-    z = m.get_cm_ref()  # numpy -> eigen
-    z[0, 2] -= 3
-    z2 = m.incr_matrix(z, 1)  # numpy -> eigen -> numpy -> eigen
-    z2[1, 1] += 6
-    z3 = m.incr_matrix(z, 2)  # (numpy -> eigen)^3
-    z3[2, 2] += -5
-    z4 = m.incr_matrix(z, 3)  # (numpy -> eigen)^4
-    z4[1, 1] -= 1
-    z5 = m.incr_matrix(z, 4)  # (numpy -> eigen)^5
-    z5[0, 0] = 0
-    assert np.all(z == z2)
-    assert np.all(z == z3)
-    assert np.all(z == z4)
-    assert np.all(z == z5)
-    expect = np.array([[0.0, 22, 20], [31, 37, 33], [41, 42, 38]])
-    assert np.all(z == expect)
-
-    y = np.array(range(100), dtype="float64").reshape(10, 10)
-    y2 = m.incr_matrix_any(y, 10)  # np -> eigen -> np
-    y3 = m.incr_matrix_any(
-        y2[0::2, 0::2], -33
-    )  # np -> eigen -> np slice -> np -> eigen -> np
-    y4 = m.even_rows(y3)  # numpy -> eigen slice -> (... y3)
-    y5 = m.even_cols(y4)  # numpy -> eigen slice -> (... y4)
-    y6 = m.incr_matrix_any(y5, 1000)  # numpy -> eigen -> (... y5)
-
-    # Apply same mutations using just numpy:
-    yexpect = np.array(range(100), dtype="float64").reshape(10, 10)
-    yexpect += 10
-    yexpect[0::2, 0::2] -= 33
-    yexpect[0::4, 0::4] += 1000
-    assert np.all(y6 == yexpect[0::4, 0::4])
-    assert np.all(y5 == yexpect[0::4, 0::4])
-    assert np.all(y4 == yexpect[0::4, 0::2])
-    assert np.all(y3 == yexpect[0::2, 0::2])
-    assert np.all(y2 == yexpect)
-    assert np.all(y == yexpect)
-
-
-def test_nocopy_wrapper():
-    # get_elem requires a column-contiguous matrix reference, but should be
-    # callable with other types of matrix (via copying):
-    int_matrix_colmajor = np.array(
-        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype="l", order="F"
-    )
-    dbl_matrix_colmajor = np.array(
-        int_matrix_colmajor, dtype="double", order="F", copy=True
-    )
-    int_matrix_rowmajor = np.array(int_matrix_colmajor, order="C", copy=True)
-    dbl_matrix_rowmajor = np.array(
-        int_matrix_rowmajor, dtype="double", order="C", copy=True
-    )
-
-    # All should be callable via get_elem:
-    assert m.get_elem(int_matrix_colmajor) == 8
-    assert m.get_elem(dbl_matrix_colmajor) == 8
-    assert m.get_elem(int_matrix_rowmajor) == 8
-    assert m.get_elem(dbl_matrix_rowmajor) == 8
-
-    # All but the second should fail with m.get_elem_nocopy:
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_nocopy(int_matrix_colmajor)
-    assert "get_elem_nocopy(): incompatible function arguments." in str(excinfo.value)
-    assert ", flags.f_contiguous" in str(excinfo.value)
-    assert m.get_elem_nocopy(dbl_matrix_colmajor) == 8
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_nocopy(int_matrix_rowmajor)
-    assert "get_elem_nocopy(): incompatible function arguments." in str(excinfo.value)
-    assert ", flags.f_contiguous" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_nocopy(dbl_matrix_rowmajor)
-    assert "get_elem_nocopy(): incompatible function arguments." in str(excinfo.value)
-    assert ", flags.f_contiguous" in str(excinfo.value)
-
-    # For the row-major test, we take a long matrix in row-major, so only the third is allowed:
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_rm_nocopy(int_matrix_colmajor)
-    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
-        excinfo.value
-    )
-    assert ", flags.c_contiguous" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_rm_nocopy(dbl_matrix_colmajor)
-    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
-        excinfo.value
-    )
-    assert ", flags.c_contiguous" in str(excinfo.value)
-    assert m.get_elem_rm_nocopy(int_matrix_rowmajor) == 8
-    with pytest.raises(TypeError) as excinfo:
-        m.get_elem_rm_nocopy(dbl_matrix_rowmajor)
-    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
-        excinfo.value
-    )
-    assert ", flags.c_contiguous" in str(excinfo.value)
-
-
-def test_eigen_ref_life_support():
-    """Ensure the lifetime of temporary arrays created by the `Ref` caster
-
-    The `Ref` caster sometimes creates a copy which needs to stay alive. This needs to
-    happen both for directs casts (just the array) or indirectly (e.g. list of arrays).
-    """
-
-    a = np.full(shape=10, fill_value=8, dtype=np.int8)
-    assert m.get_elem_direct(a) == 8
-
-    list_of_a = [a]
-    assert m.get_elem_indirect(list_of_a) == 8
-
-
-def test_special_matrix_objects():
-    assert np.all(m.incr_diag(7) == np.diag([1.0, 2, 3, 4, 5, 6, 7]))
-
-    asymm = np.array([[1.0, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
-    symm_lower = np.array(asymm)
-    symm_upper = np.array(asymm)
-    for i in range(4):
-        for j in range(i + 1, 4):
-            symm_lower[i, j] = symm_lower[j, i]
-            symm_upper[j, i] = symm_upper[i, j]
-
-    assert np.all(m.symmetric_lower(asymm) == symm_lower)
-    assert np.all(m.symmetric_upper(asymm) == symm_upper)
-
-
-def test_dense_signature(doc):
-    assert (
-        doc(m.double_col)
-        == """
-        double_col(arg0: numpy.ndarray[numpy.float32[m, 1]]) -> numpy.ndarray[numpy.float32[m, 1]]
-    """
-    )
-    assert (
-        doc(m.double_row)
-        == """
-        double_row(arg0: numpy.ndarray[numpy.float32[1, n]]) -> numpy.ndarray[numpy.float32[1, n]]
-    """
-    )
-    assert doc(m.double_complex) == (
-        """
-        double_complex(arg0: numpy.ndarray[numpy.complex64[m, 1]])"""
-        """ -> numpy.ndarray[numpy.complex64[m, 1]]
-    """
-    )
-    assert doc(m.double_mat_rm) == (
-        """
-        double_mat_rm(arg0: numpy.ndarray[numpy.float32[m, n]])"""
-        """ -> numpy.ndarray[numpy.float32[m, n]]
-    """
-    )
-
-
-def test_defaults(doc):
-    assert "\n" not in str(doc(m.defaults_mat))
-    assert "\n" not in str(doc(m.defaults_vec))
-
-
-def test_named_arguments():
-    a = np.array([[1.0, 2], [3, 4], [5, 6]])
-    b = np.ones((2, 1))
-
-    assert np.all(m.matrix_multiply(a, b) == np.array([[3.0], [7], [11]]))
-    assert np.all(m.matrix_multiply(A=a, B=b) == np.array([[3.0], [7], [11]]))
-    assert np.all(m.matrix_multiply(B=b, A=a) == np.array([[3.0], [7], [11]]))
-
-    with pytest.raises(ValueError) as excinfo:
-        m.matrix_multiply(b, a)
-    assert str(excinfo.value) == "Nonconformable matrices!"
-
-    with pytest.raises(ValueError) as excinfo:
-        m.matrix_multiply(A=b, B=a)
-    assert str(excinfo.value) == "Nonconformable matrices!"
-
-    with pytest.raises(ValueError) as excinfo:
-        m.matrix_multiply(B=a, A=b)
-    assert str(excinfo.value) == "Nonconformable matrices!"
-
-
-def test_sparse():
-    pytest.importorskip("scipy")
-    assert_sparse_equal_ref(m.sparse_r())
-    assert_sparse_equal_ref(m.sparse_c())
-    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_r()))
-    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_c()))
-    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_c()))
-    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_r()))
-
-
-def test_sparse_signature(doc):
-    pytest.importorskip("scipy")
-    assert (
-        doc(m.sparse_copy_r)
-        == """
-        sparse_copy_r(arg0: scipy.sparse.csr_matrix[numpy.float32]) -> scipy.sparse.csr_matrix[numpy.float32]
-    """
-    )
-    assert (
-        doc(m.sparse_copy_c)
-        == """
-        sparse_copy_c(arg0: scipy.sparse.csc_matrix[numpy.float32]) -> scipy.sparse.csc_matrix[numpy.float32]
-    """
-    )
-
-
-def test_issue738():
-    """Ignore strides on a length-1 dimension (even if they would be incompatible length > 1)"""
-    assert np.all(m.iss738_f1(np.array([[1.0, 2, 3]])) == np.array([[1.0, 102, 203]]))
-    assert np.all(
-        m.iss738_f1(np.array([[1.0], [2], [3]])) == np.array([[1.0], [12], [23]])
-    )
-
-    assert np.all(m.iss738_f2(np.array([[1.0, 2, 3]])) == np.array([[1.0, 102, 203]]))
-    assert np.all(
-        m.iss738_f2(np.array([[1.0], [2], [3]])) == np.array([[1.0], [12], [23]])
-    )
-
-
-@pytest.mark.parametrize("func", [m.iss738_f1, m.iss738_f2])
-@pytest.mark.parametrize("sizes", [(0, 2), (2, 0)])
-def test_zero_length(func, sizes):
-    """Ignore strides on a length-0 dimension (even if they would be incompatible length > 1)"""
-    assert np.all(func(np.zeros(sizes)) == np.zeros(sizes))
-
-
-def test_issue1105():
-    """Issue 1105: 1xN or Nx1 input arrays weren't accepted for eigen
-    compile-time row vectors or column vector"""
-    assert m.iss1105_row(np.ones((1, 7)))
-    assert m.iss1105_col(np.ones((7, 1)))
-
-    # These should still fail (incompatible dimensions):
-    with pytest.raises(TypeError) as excinfo:
-        m.iss1105_row(np.ones((7, 1)))
-    assert "incompatible function arguments" in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        m.iss1105_col(np.ones((1, 7)))
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test_custom_operator_new():
-    """Using Eigen types as member variables requires a class-specific
-    operator new with proper alignment"""
-
-    o = m.CustomOperatorNew()
-    np.testing.assert_allclose(o.a, 0.0)
-    np.testing.assert_allclose(o.b.diagonal(), 1.0)
+import pytest
+
+from pybind11_tests import ConstructorStats
+
+np = pytest.importorskip("numpy")
+m = pytest.importorskip("pybind11_tests.eigen_matrix")
+
+
+ref = np.array(
+    [
+        [0.0, 3, 0, 0, 0, 11],
+        [22, 0, 0, 0, 17, 11],
+        [7, 5, 0, 1, 0, 11],
+        [0, 0, 0, 0, 0, 11],
+        [0, 0, 14, 0, 8, 11],
+    ]
+)
+
+
+def assert_equal_ref(mat):
+    np.testing.assert_array_equal(mat, ref)
+
+
+def assert_sparse_equal_ref(sparse_mat):
+    assert_equal_ref(sparse_mat.toarray())
+
+
+def test_fixed():
+    assert_equal_ref(m.fixed_c())
+    assert_equal_ref(m.fixed_r())
+    assert_equal_ref(m.fixed_copy_r(m.fixed_r()))
+    assert_equal_ref(m.fixed_copy_c(m.fixed_c()))
+    assert_equal_ref(m.fixed_copy_r(m.fixed_c()))
+    assert_equal_ref(m.fixed_copy_c(m.fixed_r()))
+
+
+def test_dense():
+    assert_equal_ref(m.dense_r())
+    assert_equal_ref(m.dense_c())
+    assert_equal_ref(m.dense_copy_r(m.dense_r()))
+    assert_equal_ref(m.dense_copy_c(m.dense_c()))
+    assert_equal_ref(m.dense_copy_r(m.dense_c()))
+    assert_equal_ref(m.dense_copy_c(m.dense_r()))
+
+
+def test_partially_fixed():
+    ref2 = np.array([[0.0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]])
+    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2), ref2)
+    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2), ref2)
+    np.testing.assert_array_equal(m.partial_copy_four_rm_r(ref2[:, 1]), ref2[:, [1]])
+    np.testing.assert_array_equal(m.partial_copy_four_rm_c(ref2[0, :]), ref2[[0], :])
+    np.testing.assert_array_equal(
+        m.partial_copy_four_rm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)]
+    )
+    np.testing.assert_array_equal(
+        m.partial_copy_four_rm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :]
+    )
+
+    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2), ref2)
+    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2), ref2)
+    np.testing.assert_array_equal(m.partial_copy_four_cm_r(ref2[:, 1]), ref2[:, [1]])
+    np.testing.assert_array_equal(m.partial_copy_four_cm_c(ref2[0, :]), ref2[[0], :])
+    np.testing.assert_array_equal(
+        m.partial_copy_four_cm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)]
+    )
+    np.testing.assert_array_equal(
+        m.partial_copy_four_cm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :]
+    )
+
+    # TypeError should be raise for a shape mismatch
+    functions = [
+        m.partial_copy_four_rm_r,
+        m.partial_copy_four_rm_c,
+        m.partial_copy_four_cm_r,
+        m.partial_copy_four_cm_c,
+    ]
+    matrix_with_wrong_shape = [[1, 2], [3, 4]]
+    for f in functions:
+        with pytest.raises(TypeError) as excinfo:
+            f(matrix_with_wrong_shape)
+        assert "incompatible function arguments" in str(excinfo.value)
+
+
+def test_mutator_descriptors():
+    zr = np.arange(30, dtype="float32").reshape(5, 6)  # row-major
+    zc = zr.reshape(6, 5).transpose()  # column-major
+
+    m.fixed_mutator_r(zr)
+    m.fixed_mutator_c(zc)
+    m.fixed_mutator_a(zr)
+    m.fixed_mutator_a(zc)
+    with pytest.raises(TypeError) as excinfo:
+        m.fixed_mutator_r(zc)
+    assert (
+        "(arg0: numpy.ndarray[numpy.float32[5, 6],"
+        " flags.writeable, flags.c_contiguous]) -> None" in str(excinfo.value)
+    )
+    with pytest.raises(TypeError) as excinfo:
+        m.fixed_mutator_c(zr)
+    assert (
+        "(arg0: numpy.ndarray[numpy.float32[5, 6],"
+        " flags.writeable, flags.f_contiguous]) -> None" in str(excinfo.value)
+    )
+    with pytest.raises(TypeError) as excinfo:
+        m.fixed_mutator_a(np.array([[1, 2], [3, 4]], dtype="float32"))
+    assert "(arg0: numpy.ndarray[numpy.float32[5, 6], flags.writeable]) -> None" in str(
+        excinfo.value
+    )
+    zr.flags.writeable = False
+    with pytest.raises(TypeError):
+        m.fixed_mutator_r(zr)
+    with pytest.raises(TypeError):
+        m.fixed_mutator_a(zr)
+
+
+def test_cpp_casting():
+    assert m.cpp_copy(m.fixed_r()) == 22.0
+    assert m.cpp_copy(m.fixed_c()) == 22.0
+    z = np.array([[5.0, 6], [7, 8]])
+    assert m.cpp_copy(z) == 7.0
+    assert m.cpp_copy(m.get_cm_ref()) == 21.0
+    assert m.cpp_copy(m.get_rm_ref()) == 21.0
+    assert m.cpp_ref_c(m.get_cm_ref()) == 21.0
+    assert m.cpp_ref_r(m.get_rm_ref()) == 21.0
+    with pytest.raises(RuntimeError) as excinfo:
+        # Can't reference m.fixed_c: it contains floats, m.cpp_ref_any wants doubles
+        m.cpp_ref_any(m.fixed_c())
+    assert "Unable to cast Python instance" in str(excinfo.value)
+    with pytest.raises(RuntimeError) as excinfo:
+        # Can't reference m.fixed_r: it contains floats, m.cpp_ref_any wants doubles
+        m.cpp_ref_any(m.fixed_r())
+    assert "Unable to cast Python instance" in str(excinfo.value)
+    assert m.cpp_ref_any(m.ReturnTester.create()) == 1.0
+
+    assert m.cpp_ref_any(m.get_cm_ref()) == 21.0
+    assert m.cpp_ref_any(m.get_cm_ref()) == 21.0
+
+
+def test_pass_readonly_array():
+    z = np.full((5, 6), 42.0)
+    z.flags.writeable = False
+    np.testing.assert_array_equal(z, m.fixed_copy_r(z))
+    np.testing.assert_array_equal(m.fixed_r_const(), m.fixed_r())
+    assert not m.fixed_r_const().flags.writeable
+    np.testing.assert_array_equal(m.fixed_copy_r(m.fixed_r_const()), m.fixed_r_const())
+
+
+def test_nonunit_stride_from_python():
+    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
+    second_row = counting_mat[1, :]
+    second_col = counting_mat[:, 1]
+    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
+    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
+    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
+    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
+    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
+    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
+
+    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
+    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
+    for ref_mat in slices:
+        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
+        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
+
+    # Mutator:
+    m.double_threer(second_row)
+    m.double_threec(second_col)
+    np.testing.assert_array_equal(counting_mat, [[0.0, 2, 2], [6, 16, 10], [6, 14, 8]])
+
+
+def test_negative_stride_from_python(msg):
+    """Eigen doesn't support (as of yet) negative strides. When a function takes an Eigen matrix by
+    copy or const reference, we can pass a numpy array that has negative strides.  Otherwise, an
+    exception will be thrown as Eigen will not be able to map the numpy array."""
+
+    counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
+    counting_mat = counting_mat[::-1, ::-1]
+    second_row = counting_mat[1, :]
+    second_col = counting_mat[:, 1]
+    np.testing.assert_array_equal(m.double_row(second_row), 2.0 * second_row)
+    np.testing.assert_array_equal(m.double_col(second_row), 2.0 * second_row)
+    np.testing.assert_array_equal(m.double_complex(second_row), 2.0 * second_row)
+    np.testing.assert_array_equal(m.double_row(second_col), 2.0 * second_col)
+    np.testing.assert_array_equal(m.double_col(second_col), 2.0 * second_col)
+    np.testing.assert_array_equal(m.double_complex(second_col), 2.0 * second_col)
+
+    counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
+    counting_3d = counting_3d[::-1, ::-1, ::-1]
+    slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
+    for ref_mat in slices:
+        np.testing.assert_array_equal(m.double_mat_cm(ref_mat), 2.0 * ref_mat)
+        np.testing.assert_array_equal(m.double_mat_rm(ref_mat), 2.0 * ref_mat)
+
+    # Mutator:
+    with pytest.raises(TypeError) as excinfo:
+        m.double_threer(second_row)
+    assert (
+        msg(excinfo.value)
+        == """
+        double_threer(): incompatible function arguments. The following argument types are supported:
+            1. (arg0: numpy.ndarray[numpy.float32[1, 3], flags.writeable]) -> None
+
+        Invoked with: """
+        + repr(np.array([5.0, 4.0, 3.0], dtype="float32"))
+    )
+
+    with pytest.raises(TypeError) as excinfo:
+        m.double_threec(second_col)
+    assert (
+        msg(excinfo.value)
+        == """
+        double_threec(): incompatible function arguments. The following argument types are supported:
+            1. (arg0: numpy.ndarray[numpy.float32[3, 1], flags.writeable]) -> None
+
+        Invoked with: """
+        + repr(np.array([7.0, 4.0, 1.0], dtype="float32"))
+    )
+
+
+def test_block_runtime_error_type_caster_eigen_ref_made_a_copy():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.block(ref, 0, 0, 0, 0)
+    assert str(excinfo.value) == "type_caster for Eigen::Ref made a copy."
+
+
+def test_nonunit_stride_to_python():
+    assert np.all(m.diagonal(ref) == ref.diagonal())
+    assert np.all(m.diagonal_1(ref) == ref.diagonal(1))
+    for i in range(-5, 7):
+        assert np.all(m.diagonal_n(ref, i) == ref.diagonal(i)), f"m.diagonal_n({i})"
+
+    # Must be order="F", otherwise the type_caster will make a copy and
+    # m.block() will return a dangling reference (heap-use-after-free).
+    rof = np.asarray(ref, order="F")
+    assert np.all(m.block(rof, 2, 1, 3, 3) == rof[2:5, 1:4])
+    assert np.all(m.block(rof, 1, 4, 4, 2) == rof[1:, 4:])
+    assert np.all(m.block(rof, 1, 4, 3, 2) == rof[1:4, 4:])
+
+
+def test_eigen_ref_to_python():
+    chols = [m.cholesky1, m.cholesky2, m.cholesky3, m.cholesky4]
+    for i, chol in enumerate(chols, start=1):
+        mymat = chol(np.array([[1.0, 2, 4], [2, 13, 23], [4, 23, 77]]))
+        assert np.all(
+            mymat == np.array([[1, 0, 0], [2, 3, 0], [4, 5, 6]])
+        ), f"cholesky{i}"
+
+
+def assign_both(a1, a2, r, c, v):
+    a1[r, c] = v
+    a2[r, c] = v
+
+
+def array_copy_but_one(a, r, c, v):
+    z = np.array(a, copy=True)
+    z[r, c] = v
+    return z
+
+
+def test_eigen_return_references():
+    """Tests various ways of returning references and non-referencing copies"""
+
+    primary = np.ones((10, 10))
+    a = m.ReturnTester()
+    a_get1 = a.get()
+    assert not a_get1.flags.owndata
+    assert a_get1.flags.writeable
+    assign_both(a_get1, primary, 3, 3, 5)
+    a_get2 = a.get_ptr()
+    assert not a_get2.flags.owndata
+    assert a_get2.flags.writeable
+    assign_both(a_get1, primary, 2, 3, 6)
+
+    a_view1 = a.view()
+    assert not a_view1.flags.owndata
+    assert not a_view1.flags.writeable
+    with pytest.raises(ValueError):
+        a_view1[2, 3] = 4
+    a_view2 = a.view_ptr()
+    assert not a_view2.flags.owndata
+    assert not a_view2.flags.writeable
+    with pytest.raises(ValueError):
+        a_view2[2, 3] = 4
+
+    a_copy1 = a.copy_get()
+    assert a_copy1.flags.owndata
+    assert a_copy1.flags.writeable
+    np.testing.assert_array_equal(a_copy1, primary)
+    a_copy1[7, 7] = -44  # Shouldn't affect anything else
+    c1want = array_copy_but_one(primary, 7, 7, -44)
+    a_copy2 = a.copy_view()
+    assert a_copy2.flags.owndata
+    assert a_copy2.flags.writeable
+    np.testing.assert_array_equal(a_copy2, primary)
+    a_copy2[4, 4] = -22  # Shouldn't affect anything else
+    c2want = array_copy_but_one(primary, 4, 4, -22)
+
+    a_ref1 = a.ref()
+    assert not a_ref1.flags.owndata
+    assert a_ref1.flags.writeable
+    assign_both(a_ref1, primary, 1, 1, 15)
+    a_ref2 = a.ref_const()
+    assert not a_ref2.flags.owndata
+    assert not a_ref2.flags.writeable
+    with pytest.raises(ValueError):
+        a_ref2[5, 5] = 33
+    a_ref3 = a.ref_safe()
+    assert not a_ref3.flags.owndata
+    assert a_ref3.flags.writeable
+    assign_both(a_ref3, primary, 0, 7, 99)
+    a_ref4 = a.ref_const_safe()
+    assert not a_ref4.flags.owndata
+    assert not a_ref4.flags.writeable
+    with pytest.raises(ValueError):
+        a_ref4[7, 0] = 987654321
+
+    a_copy3 = a.copy_ref()
+    assert a_copy3.flags.owndata
+    assert a_copy3.flags.writeable
+    np.testing.assert_array_equal(a_copy3, primary)
+    a_copy3[8, 1] = 11
+    c3want = array_copy_but_one(primary, 8, 1, 11)
+    a_copy4 = a.copy_ref_const()
+    assert a_copy4.flags.owndata
+    assert a_copy4.flags.writeable
+    np.testing.assert_array_equal(a_copy4, primary)
+    a_copy4[8, 4] = 88
+    c4want = array_copy_but_one(primary, 8, 4, 88)
+
+    a_block1 = a.block(3, 3, 2, 2)
+    assert not a_block1.flags.owndata
+    assert a_block1.flags.writeable
+    a_block1[0, 0] = 55
+    primary[3, 3] = 55
+    a_block2 = a.block_safe(2, 2, 3, 2)
+    assert not a_block2.flags.owndata
+    assert a_block2.flags.writeable
+    a_block2[2, 1] = -123
+    primary[4, 3] = -123
+    a_block3 = a.block_const(6, 7, 4, 3)
+    assert not a_block3.flags.owndata
+    assert not a_block3.flags.writeable
+    with pytest.raises(ValueError):
+        a_block3[2, 2] = -44444
+
+    a_copy5 = a.copy_block(2, 2, 2, 3)
+    assert a_copy5.flags.owndata
+    assert a_copy5.flags.writeable
+    np.testing.assert_array_equal(a_copy5, primary[2:4, 2:5])
+    a_copy5[1, 1] = 777
+    c5want = array_copy_but_one(primary[2:4, 2:5], 1, 1, 777)
+
+    a_corn1 = a.corners()
+    assert not a_corn1.flags.owndata
+    assert a_corn1.flags.writeable
+    a_corn1 *= 50
+    a_corn1[1, 1] = 999
+    primary[0, 0] = 50
+    primary[0, 9] = 50
+    primary[9, 0] = 50
+    primary[9, 9] = 999
+    a_corn2 = a.corners_const()
+    assert not a_corn2.flags.owndata
+    assert not a_corn2.flags.writeable
+    with pytest.raises(ValueError):
+        a_corn2[1, 0] = 51
+
+    # All of the changes made all the way along should be visible everywhere
+    # now (except for the copies, of course)
+    np.testing.assert_array_equal(a_get1, primary)
+    np.testing.assert_array_equal(a_get2, primary)
+    np.testing.assert_array_equal(a_view1, primary)
+    np.testing.assert_array_equal(a_view2, primary)
+    np.testing.assert_array_equal(a_ref1, primary)
+    np.testing.assert_array_equal(a_ref2, primary)
+    np.testing.assert_array_equal(a_ref3, primary)
+    np.testing.assert_array_equal(a_ref4, primary)
+    np.testing.assert_array_equal(a_block1, primary[3:5, 3:5])
+    np.testing.assert_array_equal(a_block2, primary[2:5, 2:4])
+    np.testing.assert_array_equal(a_block3, primary[6:10, 7:10])
+    np.testing.assert_array_equal(
+        a_corn1, primary[0 :: primary.shape[0] - 1, 0 :: primary.shape[1] - 1]
+    )
+    np.testing.assert_array_equal(
+        a_corn2, primary[0 :: primary.shape[0] - 1, 0 :: primary.shape[1] - 1]
+    )
+
+    np.testing.assert_array_equal(a_copy1, c1want)
+    np.testing.assert_array_equal(a_copy2, c2want)
+    np.testing.assert_array_equal(a_copy3, c3want)
+    np.testing.assert_array_equal(a_copy4, c4want)
+    np.testing.assert_array_equal(a_copy5, c5want)
+
+
+def assert_keeps_alive(cl, method, *args):
+    cstats = ConstructorStats.get(cl)
+    start_with = cstats.alive()
+    a = cl()
+    assert cstats.alive() == start_with + 1
+    z = method(a, *args)
+    assert cstats.alive() == start_with + 1
+    del a
+    # Here's the keep alive in action:
+    assert cstats.alive() == start_with + 1
+    del z
+    # Keep alive should have expired:
+    assert cstats.alive() == start_with
+
+
+def test_eigen_keepalive():
+    a = m.ReturnTester()
+    cstats = ConstructorStats.get(m.ReturnTester)
+    assert cstats.alive() == 1
+    unsafe = [a.ref(), a.ref_const(), a.block(1, 2, 3, 4)]
+    copies = [
+        a.copy_get(),
+        a.copy_view(),
+        a.copy_ref(),
+        a.copy_ref_const(),
+        a.copy_block(4, 3, 2, 1),
+    ]
+    del a
+    assert cstats.alive() == 0
+    del unsafe
+    del copies
+
+    for meth in [
+        m.ReturnTester.get,
+        m.ReturnTester.get_ptr,
+        m.ReturnTester.view,
+        m.ReturnTester.view_ptr,
+        m.ReturnTester.ref_safe,
+        m.ReturnTester.ref_const_safe,
+        m.ReturnTester.corners,
+        m.ReturnTester.corners_const,
+    ]:
+        assert_keeps_alive(m.ReturnTester, meth)
+
+    for meth in [m.ReturnTester.block_safe, m.ReturnTester.block_const]:
+        assert_keeps_alive(m.ReturnTester, meth, 4, 3, 2, 1)
+
+
+def test_eigen_ref_mutators():
+    """Tests Eigen's ability to mutate numpy values"""
+
+    orig = np.array([[1.0, 2, 3], [4, 5, 6], [7, 8, 9]])
+    zr = np.array(orig)
+    zc = np.array(orig, order="F")
+    m.add_rm(zr, 1, 0, 100)
+    assert np.all(zr == np.array([[1.0, 2, 3], [104, 5, 6], [7, 8, 9]]))
+    m.add_cm(zc, 1, 0, 200)
+    assert np.all(zc == np.array([[1.0, 2, 3], [204, 5, 6], [7, 8, 9]]))
+
+    m.add_any(zr, 1, 0, 20)
+    assert np.all(zr == np.array([[1.0, 2, 3], [124, 5, 6], [7, 8, 9]]))
+    m.add_any(zc, 1, 0, 10)
+    assert np.all(zc == np.array([[1.0, 2, 3], [214, 5, 6], [7, 8, 9]]))
+
+    # Can't reference a col-major array with a row-major Ref, and vice versa:
+    with pytest.raises(TypeError):
+        m.add_rm(zc, 1, 0, 1)
+    with pytest.raises(TypeError):
+        m.add_cm(zr, 1, 0, 1)
+
+    # Overloads:
+    m.add1(zr, 1, 0, -100)
+    m.add2(zr, 1, 0, -20)
+    assert np.all(zr == orig)
+    m.add1(zc, 1, 0, -200)
+    m.add2(zc, 1, 0, -10)
+    assert np.all(zc == orig)
+
+    # a non-contiguous slice (this won't work on either the row- or
+    # column-contiguous refs, but should work for the any)
+    cornersr = zr[0::2, 0::2]
+    cornersc = zc[0::2, 0::2]
+
+    assert np.all(cornersr == np.array([[1.0, 3], [7, 9]]))
+    assert np.all(cornersc == np.array([[1.0, 3], [7, 9]]))
+
+    with pytest.raises(TypeError):
+        m.add_rm(cornersr, 0, 1, 25)
+    with pytest.raises(TypeError):
+        m.add_cm(cornersr, 0, 1, 25)
+    with pytest.raises(TypeError):
+        m.add_rm(cornersc, 0, 1, 25)
+    with pytest.raises(TypeError):
+        m.add_cm(cornersc, 0, 1, 25)
+    m.add_any(cornersr, 0, 1, 25)
+    m.add_any(cornersc, 0, 1, 44)
+    assert np.all(zr == np.array([[1.0, 2, 28], [4, 5, 6], [7, 8, 9]]))
+    assert np.all(zc == np.array([[1.0, 2, 47], [4, 5, 6], [7, 8, 9]]))
+
+    # You shouldn't be allowed to pass a non-writeable array to a mutating Eigen method:
+    zro = zr[0:4, 0:4]
+    zro.flags.writeable = False
+    with pytest.raises(TypeError):
+        m.add_rm(zro, 0, 0, 0)
+    with pytest.raises(TypeError):
+        m.add_any(zro, 0, 0, 0)
+    with pytest.raises(TypeError):
+        m.add1(zro, 0, 0, 0)
+    with pytest.raises(TypeError):
+        m.add2(zro, 0, 0, 0)
+
+    # integer array shouldn't be passable to a double-matrix-accepting mutating func:
+    zi = np.array([[1, 2], [3, 4]])
+    with pytest.raises(TypeError):
+        m.add_rm(zi)
+
+
+def test_numpy_ref_mutators():
+    """Tests numpy mutating Eigen matrices (for returned Eigen::Ref<...>s)"""
+
+    m.reset_refs()  # In case another test already changed it
+
+    zc = m.get_cm_ref()
+    zcro = m.get_cm_const_ref()
+    zr = m.get_rm_ref()
+    zrro = m.get_rm_const_ref()
+
+    assert [zc[1, 2], zcro[1, 2], zr[1, 2], zrro[1, 2]] == [23] * 4
+
+    assert not zc.flags.owndata
+    assert zc.flags.writeable
+    assert not zr.flags.owndata
+    assert zr.flags.writeable
+    assert not zcro.flags.owndata
+    assert not zcro.flags.writeable
+    assert not zrro.flags.owndata
+    assert not zrro.flags.writeable
+
+    zc[1, 2] = 99
+    expect = np.array([[11.0, 12, 13], [21, 22, 99], [31, 32, 33]])
+    # We should have just changed zc, of course, but also zcro and the original eigen matrix
+    assert np.all(zc == expect)
+    assert np.all(zcro == expect)
+    assert np.all(m.get_cm_ref() == expect)
+
+    zr[1, 2] = 99
+    assert np.all(zr == expect)
+    assert np.all(zrro == expect)
+    assert np.all(m.get_rm_ref() == expect)
+
+    # Make sure the readonly ones are numpy-readonly:
+    with pytest.raises(ValueError):
+        zcro[1, 2] = 6
+    with pytest.raises(ValueError):
+        zrro[1, 2] = 6
+
+    # We should be able to explicitly copy like this (and since we're copying,
+    # the const should drop away)
+    y1 = np.array(m.get_cm_const_ref())
+
+    assert y1.flags.owndata
+    assert y1.flags.writeable
+    # We should get copies of the eigen data, which was modified above:
+    assert y1[1, 2] == 99
+    y1[1, 2] += 12
+    assert y1[1, 2] == 111
+    assert zc[1, 2] == 99  # Make sure we aren't referencing the original
+
+
+def test_both_ref_mutators():
+    """Tests a complex chain of nested eigen/numpy references"""
+
+    m.reset_refs()  # In case another test already changed it
+
+    z = m.get_cm_ref()  # numpy -> eigen
+    z[0, 2] -= 3
+    z2 = m.incr_matrix(z, 1)  # numpy -> eigen -> numpy -> eigen
+    z2[1, 1] += 6
+    z3 = m.incr_matrix(z, 2)  # (numpy -> eigen)^3
+    z3[2, 2] += -5
+    z4 = m.incr_matrix(z, 3)  # (numpy -> eigen)^4
+    z4[1, 1] -= 1
+    z5 = m.incr_matrix(z, 4)  # (numpy -> eigen)^5
+    z5[0, 0] = 0
+    assert np.all(z == z2)
+    assert np.all(z == z3)
+    assert np.all(z == z4)
+    assert np.all(z == z5)
+    expect = np.array([[0.0, 22, 20], [31, 37, 33], [41, 42, 38]])
+    assert np.all(z == expect)
+
+    y = np.array(range(100), dtype="float64").reshape(10, 10)
+    y2 = m.incr_matrix_any(y, 10)  # np -> eigen -> np
+    y3 = m.incr_matrix_any(
+        y2[0::2, 0::2], -33
+    )  # np -> eigen -> np slice -> np -> eigen -> np
+    y4 = m.even_rows(y3)  # numpy -> eigen slice -> (... y3)
+    y5 = m.even_cols(y4)  # numpy -> eigen slice -> (... y4)
+    y6 = m.incr_matrix_any(y5, 1000)  # numpy -> eigen -> (... y5)
+
+    # Apply same mutations using just numpy:
+    yexpect = np.array(range(100), dtype="float64").reshape(10, 10)
+    yexpect += 10
+    yexpect[0::2, 0::2] -= 33
+    yexpect[0::4, 0::4] += 1000
+    assert np.all(y6 == yexpect[0::4, 0::4])
+    assert np.all(y5 == yexpect[0::4, 0::4])
+    assert np.all(y4 == yexpect[0::4, 0::2])
+    assert np.all(y3 == yexpect[0::2, 0::2])
+    assert np.all(y2 == yexpect)
+    assert np.all(y == yexpect)
+
+
+def test_nocopy_wrapper():
+    # get_elem requires a column-contiguous matrix reference, but should be
+    # callable with other types of matrix (via copying):
+    int_matrix_colmajor = np.array(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype="l", order="F"
+    )
+    dbl_matrix_colmajor = np.array(
+        int_matrix_colmajor, dtype="double", order="F", copy=True
+    )
+    int_matrix_rowmajor = np.array(int_matrix_colmajor, order="C", copy=True)
+    dbl_matrix_rowmajor = np.array(
+        int_matrix_rowmajor, dtype="double", order="C", copy=True
+    )
+
+    # All should be callable via get_elem:
+    assert m.get_elem(int_matrix_colmajor) == 8
+    assert m.get_elem(dbl_matrix_colmajor) == 8
+    assert m.get_elem(int_matrix_rowmajor) == 8
+    assert m.get_elem(dbl_matrix_rowmajor) == 8
+
+    # All but the second should fail with m.get_elem_nocopy:
+    with pytest.raises(TypeError) as excinfo:
+        m.get_elem_nocopy(int_matrix_colmajor)
+    assert "get_elem_nocopy(): incompatible function arguments." in str(excinfo.value)
+    assert ", flags.f_contiguous" in str(excinfo.value)
+    assert m.get_elem_nocopy(dbl_matrix_colmajor) == 8
+    with pytest.raises(TypeError) as excinfo:
+        m.get_elem_nocopy(int_matrix_rowmajor)
+    assert "get_elem_nocopy(): incompatible function arguments." in str(excinfo.value)
+    assert ", flags.f_contiguous" in str(excinfo.value)
+    with pytest.raises(TypeError) as excinfo:
+        m.get_elem_nocopy(dbl_matrix_rowmajor)
+    assert "get_elem_nocopy(): incompatible function arguments." in str(excinfo.value)
+    assert ", flags.f_contiguous" in str(excinfo.value)
+
+    # For the row-major test, we take a long matrix in row-major, so only the third is allowed:
+    with pytest.raises(TypeError) as excinfo:
+        m.get_elem_rm_nocopy(int_matrix_colmajor)
+    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
+        excinfo.value
+    )
+    assert ", flags.c_contiguous" in str(excinfo.value)
+    with pytest.raises(TypeError) as excinfo:
+        m.get_elem_rm_nocopy(dbl_matrix_colmajor)
+    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
+        excinfo.value
+    )
+    assert ", flags.c_contiguous" in str(excinfo.value)
+    assert m.get_elem_rm_nocopy(int_matrix_rowmajor) == 8
+    with pytest.raises(TypeError) as excinfo:
+        m.get_elem_rm_nocopy(dbl_matrix_rowmajor)
+    assert "get_elem_rm_nocopy(): incompatible function arguments." in str(
+        excinfo.value
+    )
+    assert ", flags.c_contiguous" in str(excinfo.value)
+
+
+def test_eigen_ref_life_support():
+    """Ensure the lifetime of temporary arrays created by the `Ref` caster
+
+    The `Ref` caster sometimes creates a copy which needs to stay alive. This needs to
+    happen both for directs casts (just the array) or indirectly (e.g. list of arrays).
+    """
+
+    a = np.full(shape=10, fill_value=8, dtype=np.int8)
+    assert m.get_elem_direct(a) == 8
+
+    list_of_a = [a]
+    assert m.get_elem_indirect(list_of_a) == 8
+
+
+def test_special_matrix_objects():
+    assert np.all(m.incr_diag(7) == np.diag([1.0, 2, 3, 4, 5, 6, 7]))
+
+    asymm = np.array([[1.0, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+    symm_lower = np.array(asymm)
+    symm_upper = np.array(asymm)
+    for i in range(4):
+        for j in range(i + 1, 4):
+            symm_lower[i, j] = symm_lower[j, i]
+            symm_upper[j, i] = symm_upper[i, j]
+
+    assert np.all(m.symmetric_lower(asymm) == symm_lower)
+    assert np.all(m.symmetric_upper(asymm) == symm_upper)
+
+
+def test_dense_signature(doc):
+    assert (
+        doc(m.double_col)
+        == """
+        double_col(arg0: numpy.ndarray[numpy.float32[m, 1]]) -> numpy.ndarray[numpy.float32[m, 1]]
+    """
+    )
+    assert (
+        doc(m.double_row)
+        == """
+        double_row(arg0: numpy.ndarray[numpy.float32[1, n]]) -> numpy.ndarray[numpy.float32[1, n]]
+    """
+    )
+    assert doc(m.double_complex) == (
+        """
+        double_complex(arg0: numpy.ndarray[numpy.complex64[m, 1]])"""
+        """ -> numpy.ndarray[numpy.complex64[m, 1]]
+    """
+    )
+    assert doc(m.double_mat_rm) == (
+        """
+        double_mat_rm(arg0: numpy.ndarray[numpy.float32[m, n]])"""
+        """ -> numpy.ndarray[numpy.float32[m, n]]
+    """
+    )
+
+
+def test_defaults(doc):
+    assert "\n" not in str(doc(m.defaults_mat))
+    assert "\n" not in str(doc(m.defaults_vec))
+
+
+def test_named_arguments():
+    a = np.array([[1.0, 2], [3, 4], [5, 6]])
+    b = np.ones((2, 1))
+
+    assert np.all(m.matrix_multiply(a, b) == np.array([[3.0], [7], [11]]))
+    assert np.all(m.matrix_multiply(A=a, B=b) == np.array([[3.0], [7], [11]]))
+    assert np.all(m.matrix_multiply(B=b, A=a) == np.array([[3.0], [7], [11]]))
+
+    with pytest.raises(ValueError) as excinfo:
+        m.matrix_multiply(b, a)
+    assert str(excinfo.value) == "Nonconformable matrices!"
+
+    with pytest.raises(ValueError) as excinfo:
+        m.matrix_multiply(A=b, B=a)
+    assert str(excinfo.value) == "Nonconformable matrices!"
+
+    with pytest.raises(ValueError) as excinfo:
+        m.matrix_multiply(B=a, A=b)
+    assert str(excinfo.value) == "Nonconformable matrices!"
+
+
+def test_sparse():
+    pytest.importorskip("scipy")
+    assert_sparse_equal_ref(m.sparse_r())
+    assert_sparse_equal_ref(m.sparse_c())
+    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_r()))
+    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_c()))
+    assert_sparse_equal_ref(m.sparse_copy_r(m.sparse_c()))
+    assert_sparse_equal_ref(m.sparse_copy_c(m.sparse_r()))
+
+
+def test_sparse_signature(doc):
+    pytest.importorskip("scipy")
+    assert (
+        doc(m.sparse_copy_r)
+        == """
+        sparse_copy_r(arg0: scipy.sparse.csr_matrix[numpy.float32]) -> scipy.sparse.csr_matrix[numpy.float32]
+    """
+    )
+    assert (
+        doc(m.sparse_copy_c)
+        == """
+        sparse_copy_c(arg0: scipy.sparse.csc_matrix[numpy.float32]) -> scipy.sparse.csc_matrix[numpy.float32]
+    """
+    )
+
+
+def test_issue738():
+    """Ignore strides on a length-1 dimension (even if they would be incompatible length > 1)"""
+    assert np.all(m.iss738_f1(np.array([[1.0, 2, 3]])) == np.array([[1.0, 102, 203]]))
+    assert np.all(
+        m.iss738_f1(np.array([[1.0], [2], [3]])) == np.array([[1.0], [12], [23]])
+    )
+
+    assert np.all(m.iss738_f2(np.array([[1.0, 2, 3]])) == np.array([[1.0, 102, 203]]))
+    assert np.all(
+        m.iss738_f2(np.array([[1.0], [2], [3]])) == np.array([[1.0], [12], [23]])
+    )
+
+
+@pytest.mark.parametrize("func", [m.iss738_f1, m.iss738_f2])
+@pytest.mark.parametrize("sizes", [(0, 2), (2, 0)])
+def test_zero_length(func, sizes):
+    """Ignore strides on a length-0 dimension (even if they would be incompatible length > 1)"""
+    assert np.all(func(np.zeros(sizes)) == np.zeros(sizes))
+
+
+def test_issue1105():
+    """Issue 1105: 1xN or Nx1 input arrays weren't accepted for eigen
+    compile-time row vectors or column vector"""
+    assert m.iss1105_row(np.ones((1, 7)))
+    assert m.iss1105_col(np.ones((7, 1)))
+
+    # These should still fail (incompatible dimensions):
+    with pytest.raises(TypeError) as excinfo:
+        m.iss1105_row(np.ones((7, 1)))
+    assert "incompatible function arguments" in str(excinfo.value)
+    with pytest.raises(TypeError) as excinfo:
+        m.iss1105_col(np.ones((1, 7)))
+    assert "incompatible function arguments" in str(excinfo.value)
+
+
+def test_custom_operator_new():
+    """Using Eigen types as member variables requires a class-specific
+    operator new with proper alignment"""
+
+    o = m.CustomOperatorNew()
+    np.testing.assert_allclose(o.a, 0.0)
+    np.testing.assert_allclose(o.b.diagonal(), 1.0)

third_party/CityFlow/extern/pybind11/tests/test_eigen_tensor.cpp

@@ -1,18 +1,18 @@
-/*
-    tests/eigen_tensor.cpp -- automatic conversion of Eigen Tensor
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#define PYBIND11_TEST_EIGEN_TENSOR_NAMESPACE eigen_tensor
-
-#ifdef EIGEN_AVOID_STL_ARRAY
-#    undef EIGEN_AVOID_STL_ARRAY
-#endif
-
-#include "test_eigen_tensor.inl"
-
-#include "pybind11_tests.h"
-
-test_initializer egien_tensor("eigen_tensor", eigen_tensor_test::test_module);
+/*
+    tests/eigen_tensor.cpp -- automatic conversion of Eigen Tensor
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#define PYBIND11_TEST_EIGEN_TENSOR_NAMESPACE eigen_tensor
+
+#ifdef EIGEN_AVOID_STL_ARRAY
+#    undef EIGEN_AVOID_STL_ARRAY
+#endif
+
+#include "test_eigen_tensor.inl"
+
+#include "pybind11_tests.h"
+
+test_initializer egien_tensor("eigen_tensor", eigen_tensor_test::test_module);

third_party/CityFlow/extern/pybind11/tests/test_eigen_tensor.inl

@@ -1,333 +1,333 @@
-/*
-    tests/eigen_tensor.cpp -- automatic conversion of Eigen Tensor
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/eigen/tensor.h>
-
-PYBIND11_NAMESPACE_BEGIN(eigen_tensor_test)
-
-namespace py = pybind11;
-
-PYBIND11_WARNING_DISABLE_MSVC(4127)
-
-template <typename M>
-void reset_tensor(M &x) {
-    for (int i = 0; i < x.dimension(0); i++) {
-        for (int j = 0; j < x.dimension(1); j++) {
-            for (int k = 0; k < x.dimension(2); k++) {
-                x(i, j, k) = i * (5 * 2) + j * 2 + k;
-            }
-        }
-    }
-}
-
-template <typename M>
-bool check_tensor(M &x) {
-    for (int i = 0; i < x.dimension(0); i++) {
-        for (int j = 0; j < x.dimension(1); j++) {
-            for (int k = 0; k < x.dimension(2); k++) {
-                if (x(i, j, k) != (i * (5 * 2) + j * 2 + k)) {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-}
-
-template <int Options>
-Eigen::Tensor<double, 3, Options> &get_tensor() {
-    static Eigen::Tensor<double, 3, Options> *x;
-
-    if (!x) {
-        x = new Eigen::Tensor<double, 3, Options>(3, 5, 2);
-        reset_tensor(*x);
-    }
-
-    return *x;
-}
-
-template <int Options>
-Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> &get_tensor_map() {
-    static Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> *x;
-
-    if (!x) {
-        x = new Eigen::TensorMap<Eigen::Tensor<double, 3, Options>>(get_tensor<Options>());
-    }
-
-    return *x;
-}
-
-template <int Options>
-Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> &get_fixed_tensor() {
-    static Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> *x;
-
-    if (!x) {
-        Eigen::aligned_allocator<Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>>
-            allocator;
-        x = new (allocator.allocate(1))
-            Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>();
-        reset_tensor(*x);
-    }
-
-    return *x;
-}
-
-template <int Options>
-const Eigen::Tensor<double, 3, Options> &get_const_tensor() {
-    return get_tensor<Options>();
-}
-
-template <int Options>
-struct CustomExample {
-    CustomExample() : member(get_tensor<Options>()), view_member(member) {}
-
-    Eigen::Tensor<double, 3, Options> member;
-    Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> view_member;
-};
-
-template <int Options>
-void init_tensor_module(pybind11::module &m) {
-    const char *needed_options = "";
-    if (Options == Eigen::ColMajor) {
-        needed_options = "F";
-    } else {
-        needed_options = "C";
-    }
-    m.attr("needed_options") = needed_options;
-
-    m.def("setup", []() {
-        reset_tensor(get_tensor<Options>());
-        reset_tensor(get_fixed_tensor<Options>());
-    });
-
-    m.def("is_ok", []() {
-        return check_tensor(get_tensor<Options>()) && check_tensor(get_fixed_tensor<Options>());
-    });
-
-    py::class_<CustomExample<Options>>(m, "CustomExample", py::module_local())
-        .def(py::init<>())
-        .def_readonly(
-            "member", &CustomExample<Options>::member, py::return_value_policy::reference_internal)
-        .def_readonly("member_view",
-                      &CustomExample<Options>::view_member,
-                      py::return_value_policy::reference_internal);
-
-    m.def(
-        "copy_fixed_tensor",
-        []() { return &get_fixed_tensor<Options>(); },
-        py::return_value_policy::copy);
-
-    m.def(
-        "copy_tensor", []() { return &get_tensor<Options>(); }, py::return_value_policy::copy);
-
-    m.def(
-        "copy_const_tensor",
-        []() { return &get_const_tensor<Options>(); },
-        py::return_value_policy::copy);
-
-    m.def(
-        "move_fixed_tensor_copy",
-        []() -> Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> {
-            return get_fixed_tensor<Options>();
-        },
-        py::return_value_policy::move);
-
-    m.def(
-        "move_tensor_copy",
-        []() -> Eigen::Tensor<double, 3, Options> { return get_tensor<Options>(); },
-        py::return_value_policy::move);
-
-    m.def(
-        "move_const_tensor",
-        []() -> const Eigen::Tensor<double, 3, Options> & { return get_const_tensor<Options>(); },
-        py::return_value_policy::move);
-
-    m.def(
-        "take_fixed_tensor",
-
-        []() {
-            Eigen::aligned_allocator<
-                Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>>
-                allocator;
-            return new (allocator.allocate(1))
-                Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>(
-                    get_fixed_tensor<Options>());
-        },
-        py::return_value_policy::take_ownership);
-
-    m.def(
-        "take_tensor",
-        []() { return new Eigen::Tensor<double, 3, Options>(get_tensor<Options>()); },
-        py::return_value_policy::take_ownership);
-
-    m.def(
-        "take_const_tensor",
-        []() -> const Eigen::Tensor<double, 3, Options> * {
-            return new Eigen::Tensor<double, 3, Options>(get_tensor<Options>());
-        },
-        py::return_value_policy::take_ownership);
-
-    m.def(
-        "take_view_tensor",
-        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> * {
-            return new Eigen::TensorMap<Eigen::Tensor<double, 3, Options>>(get_tensor<Options>());
-        },
-        py::return_value_policy::take_ownership);
-
-    m.def(
-        "reference_tensor",
-        []() { return &get_tensor<Options>(); },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_tensor_v2",
-        []() -> Eigen::Tensor<double, 3, Options> & { return get_tensor<Options>(); },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_tensor_internal",
-        []() { return &get_tensor<Options>(); },
-        py::return_value_policy::reference_internal);
-
-    m.def(
-        "reference_fixed_tensor",
-        []() { return &get_tensor<Options>(); },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_const_tensor",
-        []() { return &get_const_tensor<Options>(); },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_const_tensor_v2",
-        []() -> const Eigen::Tensor<double, 3, Options> & { return get_const_tensor<Options>(); },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_view_of_tensor",
-        []() -> Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> {
-            return get_tensor_map<Options>();
-        },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_view_of_tensor_v2",
-        // NOLINTNEXTLINE(readability-const-return-type)
-        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> {
-            return get_tensor_map<Options>(); // NOLINT(readability-const-return-type)
-        },                                    // NOLINT(readability-const-return-type)
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_view_of_tensor_v3",
-        []() -> Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> * {
-            return &get_tensor_map<Options>();
-        },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_view_of_tensor_v4",
-        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> * {
-            return &get_tensor_map<Options>();
-        },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_view_of_tensor_v5",
-        []() -> Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> & {
-            return get_tensor_map<Options>();
-        },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_view_of_tensor_v6",
-        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> & {
-            return get_tensor_map<Options>();
-        },
-        py::return_value_policy::reference);
-
-    m.def(
-        "reference_view_of_fixed_tensor",
-        []() {
-            return Eigen::TensorMap<
-                Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>>(
-                get_fixed_tensor<Options>());
-        },
-        py::return_value_policy::reference);
-
-    m.def("round_trip_tensor",
-          [](const Eigen::Tensor<double, 3, Options> &tensor) { return tensor; });
-
-    m.def(
-        "round_trip_tensor_noconvert",
-        [](const Eigen::Tensor<double, 3, Options> &tensor) { return tensor; },
-        py::arg("tensor").noconvert());
-
-    m.def("round_trip_tensor2",
-          [](const Eigen::Tensor<int32_t, 3, Options> &tensor) { return tensor; });
-
-    m.def("round_trip_fixed_tensor",
-          [](const Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> &tensor) {
-              return tensor;
-          });
-
-    m.def(
-        "round_trip_view_tensor",
-        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> view) { return view; },
-        py::return_value_policy::reference);
-
-    m.def(
-        "round_trip_view_tensor_ref",
-        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> &view) { return view; },
-        py::return_value_policy::reference);
-
-    m.def(
-        "round_trip_view_tensor_ptr",
-        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> *view) { return view; },
-        py::return_value_policy::reference);
-
-    m.def(
-        "round_trip_aligned_view_tensor",
-        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>, Eigen::Aligned> view) {
-            return view;
-        },
-        py::return_value_policy::reference);
-
-    m.def(
-        "round_trip_const_view_tensor",
-        [](Eigen::TensorMap<const Eigen::Tensor<double, 3, Options>> view) {
-            return Eigen::Tensor<double, 3, Options>(view);
-        },
-        py::return_value_policy::move);
-
-    m.def(
-        "round_trip_rank_0",
-        [](const Eigen::Tensor<double, 0, Options> &tensor) { return tensor; },
-        py::return_value_policy::move);
-
-    m.def(
-        "round_trip_rank_0_noconvert",
-        [](const Eigen::Tensor<double, 0, Options> &tensor) { return tensor; },
-        py::arg("tensor").noconvert(),
-        py::return_value_policy::move);
-
-    m.def(
-        "round_trip_rank_0_view",
-        [](Eigen::TensorMap<Eigen::Tensor<double, 0, Options>> &tensor) { return tensor; },
-        py::return_value_policy::reference);
-}
-
-void test_module(py::module_ &m) {
-    auto f_style = m.def_submodule("f_style");
-    auto c_style = m.def_submodule("c_style");
-
-    init_tensor_module<Eigen::ColMajor>(f_style);
-    init_tensor_module<Eigen::RowMajor>(c_style);
-}
-
-PYBIND11_NAMESPACE_END(eigen_tensor_test)
+/*
+    tests/eigen_tensor.cpp -- automatic conversion of Eigen Tensor
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/eigen/tensor.h>
+
+PYBIND11_NAMESPACE_BEGIN(eigen_tensor_test)
+
+namespace py = pybind11;
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+template <typename M>
+void reset_tensor(M &x) {
+    for (int i = 0; i < x.dimension(0); i++) {
+        for (int j = 0; j < x.dimension(1); j++) {
+            for (int k = 0; k < x.dimension(2); k++) {
+                x(i, j, k) = i * (5 * 2) + j * 2 + k;
+            }
+        }
+    }
+}
+
+template <typename M>
+bool check_tensor(M &x) {
+    for (int i = 0; i < x.dimension(0); i++) {
+        for (int j = 0; j < x.dimension(1); j++) {
+            for (int k = 0; k < x.dimension(2); k++) {
+                if (x(i, j, k) != (i * (5 * 2) + j * 2 + k)) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+
+template <int Options>
+Eigen::Tensor<double, 3, Options> &get_tensor() {
+    static Eigen::Tensor<double, 3, Options> *x;
+
+    if (!x) {
+        x = new Eigen::Tensor<double, 3, Options>(3, 5, 2);
+        reset_tensor(*x);
+    }
+
+    return *x;
+}
+
+template <int Options>
+Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> &get_tensor_map() {
+    static Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> *x;
+
+    if (!x) {
+        x = new Eigen::TensorMap<Eigen::Tensor<double, 3, Options>>(get_tensor<Options>());
+    }
+
+    return *x;
+}
+
+template <int Options>
+Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> &get_fixed_tensor() {
+    static Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> *x;
+
+    if (!x) {
+        Eigen::aligned_allocator<Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>>
+            allocator;
+        x = new (allocator.allocate(1))
+            Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>();
+        reset_tensor(*x);
+    }
+
+    return *x;
+}
+
+template <int Options>
+const Eigen::Tensor<double, 3, Options> &get_const_tensor() {
+    return get_tensor<Options>();
+}
+
+template <int Options>
+struct CustomExample {
+    CustomExample() : member(get_tensor<Options>()), view_member(member) {}
+
+    Eigen::Tensor<double, 3, Options> member;
+    Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> view_member;
+};
+
+template <int Options>
+void init_tensor_module(pybind11::module &m) {
+    const char *needed_options = "";
+    if (Options == Eigen::ColMajor) {
+        needed_options = "F";
+    } else {
+        needed_options = "C";
+    }
+    m.attr("needed_options") = needed_options;
+
+    m.def("setup", []() {
+        reset_tensor(get_tensor<Options>());
+        reset_tensor(get_fixed_tensor<Options>());
+    });
+
+    m.def("is_ok", []() {
+        return check_tensor(get_tensor<Options>()) && check_tensor(get_fixed_tensor<Options>());
+    });
+
+    py::class_<CustomExample<Options>>(m, "CustomExample", py::module_local())
+        .def(py::init<>())
+        .def_readonly(
+            "member", &CustomExample<Options>::member, py::return_value_policy::reference_internal)
+        .def_readonly("member_view",
+                      &CustomExample<Options>::view_member,
+                      py::return_value_policy::reference_internal);
+
+    m.def(
+        "copy_fixed_tensor",
+        []() { return &get_fixed_tensor<Options>(); },
+        py::return_value_policy::copy);
+
+    m.def(
+        "copy_tensor", []() { return &get_tensor<Options>(); }, py::return_value_policy::copy);
+
+    m.def(
+        "copy_const_tensor",
+        []() { return &get_const_tensor<Options>(); },
+        py::return_value_policy::copy);
+
+    m.def(
+        "move_fixed_tensor_copy",
+        []() -> Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> {
+            return get_fixed_tensor<Options>();
+        },
+        py::return_value_policy::move);
+
+    m.def(
+        "move_tensor_copy",
+        []() -> Eigen::Tensor<double, 3, Options> { return get_tensor<Options>(); },
+        py::return_value_policy::move);
+
+    m.def(
+        "move_const_tensor",
+        []() -> const Eigen::Tensor<double, 3, Options> & { return get_const_tensor<Options>(); },
+        py::return_value_policy::move);
+
+    m.def(
+        "take_fixed_tensor",
+
+        []() {
+            Eigen::aligned_allocator<
+                Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>>
+                allocator;
+            return new (allocator.allocate(1))
+                Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>(
+                    get_fixed_tensor<Options>());
+        },
+        py::return_value_policy::take_ownership);
+
+    m.def(
+        "take_tensor",
+        []() { return new Eigen::Tensor<double, 3, Options>(get_tensor<Options>()); },
+        py::return_value_policy::take_ownership);
+
+    m.def(
+        "take_const_tensor",
+        []() -> const Eigen::Tensor<double, 3, Options> * {
+            return new Eigen::Tensor<double, 3, Options>(get_tensor<Options>());
+        },
+        py::return_value_policy::take_ownership);
+
+    m.def(
+        "take_view_tensor",
+        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> * {
+            return new Eigen::TensorMap<Eigen::Tensor<double, 3, Options>>(get_tensor<Options>());
+        },
+        py::return_value_policy::take_ownership);
+
+    m.def(
+        "reference_tensor",
+        []() { return &get_tensor<Options>(); },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_tensor_v2",
+        []() -> Eigen::Tensor<double, 3, Options> & { return get_tensor<Options>(); },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_tensor_internal",
+        []() { return &get_tensor<Options>(); },
+        py::return_value_policy::reference_internal);
+
+    m.def(
+        "reference_fixed_tensor",
+        []() { return &get_tensor<Options>(); },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_const_tensor",
+        []() { return &get_const_tensor<Options>(); },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_const_tensor_v2",
+        []() -> const Eigen::Tensor<double, 3, Options> & { return get_const_tensor<Options>(); },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_view_of_tensor",
+        []() -> Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> {
+            return get_tensor_map<Options>();
+        },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_view_of_tensor_v2",
+        // NOLINTNEXTLINE(readability-const-return-type)
+        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> {
+            return get_tensor_map<Options>(); // NOLINT(readability-const-return-type)
+        },                                    // NOLINT(readability-const-return-type)
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_view_of_tensor_v3",
+        []() -> Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> * {
+            return &get_tensor_map<Options>();
+        },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_view_of_tensor_v4",
+        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> * {
+            return &get_tensor_map<Options>();
+        },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_view_of_tensor_v5",
+        []() -> Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> & {
+            return get_tensor_map<Options>();
+        },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_view_of_tensor_v6",
+        []() -> const Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> & {
+            return get_tensor_map<Options>();
+        },
+        py::return_value_policy::reference);
+
+    m.def(
+        "reference_view_of_fixed_tensor",
+        []() {
+            return Eigen::TensorMap<
+                Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options>>(
+                get_fixed_tensor<Options>());
+        },
+        py::return_value_policy::reference);
+
+    m.def("round_trip_tensor",
+          [](const Eigen::Tensor<double, 3, Options> &tensor) { return tensor; });
+
+    m.def(
+        "round_trip_tensor_noconvert",
+        [](const Eigen::Tensor<double, 3, Options> &tensor) { return tensor; },
+        py::arg("tensor").noconvert());
+
+    m.def("round_trip_tensor2",
+          [](const Eigen::Tensor<int32_t, 3, Options> &tensor) { return tensor; });
+
+    m.def("round_trip_fixed_tensor",
+          [](const Eigen::TensorFixedSize<double, Eigen::Sizes<3, 5, 2>, Options> &tensor) {
+              return tensor;
+          });
+
+    m.def(
+        "round_trip_view_tensor",
+        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> view) { return view; },
+        py::return_value_policy::reference);
+
+    m.def(
+        "round_trip_view_tensor_ref",
+        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> &view) { return view; },
+        py::return_value_policy::reference);
+
+    m.def(
+        "round_trip_view_tensor_ptr",
+        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>> *view) { return view; },
+        py::return_value_policy::reference);
+
+    m.def(
+        "round_trip_aligned_view_tensor",
+        [](Eigen::TensorMap<Eigen::Tensor<double, 3, Options>, Eigen::Aligned> view) {
+            return view;
+        },
+        py::return_value_policy::reference);
+
+    m.def(
+        "round_trip_const_view_tensor",
+        [](Eigen::TensorMap<const Eigen::Tensor<double, 3, Options>> view) {
+            return Eigen::Tensor<double, 3, Options>(view);
+        },
+        py::return_value_policy::move);
+
+    m.def(
+        "round_trip_rank_0",
+        [](const Eigen::Tensor<double, 0, Options> &tensor) { return tensor; },
+        py::return_value_policy::move);
+
+    m.def(
+        "round_trip_rank_0_noconvert",
+        [](const Eigen::Tensor<double, 0, Options> &tensor) { return tensor; },
+        py::arg("tensor").noconvert(),
+        py::return_value_policy::move);
+
+    m.def(
+        "round_trip_rank_0_view",
+        [](Eigen::TensorMap<Eigen::Tensor<double, 0, Options>> &tensor) { return tensor; },
+        py::return_value_policy::reference);
+}
+
+void test_module(py::module_ &m) {
+    auto f_style = m.def_submodule("f_style");
+    auto c_style = m.def_submodule("c_style");
+
+    init_tensor_module<Eigen::ColMajor>(f_style);
+    init_tensor_module<Eigen::RowMajor>(c_style);
+}
+
+PYBIND11_NAMESPACE_END(eigen_tensor_test)

third_party/CityFlow/extern/pybind11/tests/test_eigen_tensor.py

@@ -1,288 +1,288 @@
-import sys
-
-import pytest
-
-np = pytest.importorskip("numpy")
-eigen_tensor = pytest.importorskip("pybind11_tests.eigen_tensor")
-submodules = [eigen_tensor.c_style, eigen_tensor.f_style]
-try:
-    import eigen_tensor_avoid_stl_array as avoid
-
-    submodules += [avoid.c_style, avoid.f_style]
-except ImportError as e:
-    # Ensure config, build, toolchain, etc. issues are not masked here:
-    msg = (
-        "import eigen_tensor_avoid_stl_array FAILED, while "
-        "import pybind11_tests.eigen_tensor succeeded. "
-        "Please ensure that "
-        "test_eigen_tensor.cpp & "
-        "eigen_tensor_avoid_stl_array.cpp "
-        "are built together (or both are not built if Eigen is not available)."
-    )
-    raise RuntimeError(msg) from e
-
-tensor_ref = np.empty((3, 5, 2), dtype=np.int64)
-
-for i in range(tensor_ref.shape[0]):
-    for j in range(tensor_ref.shape[1]):
-        for k in range(tensor_ref.shape[2]):
-            tensor_ref[i, j, k] = i * (5 * 2) + j * 2 + k
-
-indices = (2, 3, 1)
-
-
-@pytest.fixture(autouse=True)
-def cleanup():
-    for module in submodules:
-        module.setup()
-
-    yield
-
-    for module in submodules:
-        assert module.is_ok()
-
-
-def test_import_avoid_stl_array():
-    pytest.importorskip("eigen_tensor_avoid_stl_array")
-    assert len(submodules) == 4
-
-
-def assert_equal_tensor_ref(mat, writeable=True, modified=None):
-    assert mat.flags.writeable == writeable
-
-    copy = np.array(tensor_ref)
-    if modified is not None:
-        copy[indices] = modified
-
-    np.testing.assert_array_equal(mat, copy)
-
-
-@pytest.mark.parametrize("m", submodules)
-@pytest.mark.parametrize("member_name", ["member", "member_view"])
-def test_reference_internal(m, member_name):
-    if not hasattr(sys, "getrefcount"):
-        pytest.skip("No reference counting")
-    foo = m.CustomExample()
-    counts = sys.getrefcount(foo)
-    mem = getattr(foo, member_name)
-    assert_equal_tensor_ref(mem, writeable=False)
-    new_counts = sys.getrefcount(foo)
-    assert new_counts == counts + 1
-    assert_equal_tensor_ref(mem, writeable=False)
-    del mem
-    assert sys.getrefcount(foo) == counts
-
-
-assert_equal_funcs = [
-    "copy_tensor",
-    "copy_fixed_tensor",
-    "copy_const_tensor",
-    "move_tensor_copy",
-    "move_fixed_tensor_copy",
-    "take_tensor",
-    "take_fixed_tensor",
-    "reference_tensor",
-    "reference_tensor_v2",
-    "reference_fixed_tensor",
-    "reference_view_of_tensor",
-    "reference_view_of_tensor_v3",
-    "reference_view_of_tensor_v5",
-    "reference_view_of_fixed_tensor",
-]
-
-assert_equal_const_funcs = [
-    "reference_view_of_tensor_v2",
-    "reference_view_of_tensor_v4",
-    "reference_view_of_tensor_v6",
-    "reference_const_tensor",
-    "reference_const_tensor_v2",
-]
-
-
-@pytest.mark.parametrize("m", submodules)
-@pytest.mark.parametrize("func_name", assert_equal_funcs + assert_equal_const_funcs)
-def test_convert_tensor_to_py(m, func_name):
-    writeable = func_name in assert_equal_funcs
-    assert_equal_tensor_ref(getattr(m, func_name)(), writeable=writeable)
-
-
-@pytest.mark.parametrize("m", submodules)
-def test_bad_cpp_to_python_casts(m):
-    with pytest.raises(
-        RuntimeError, match="Cannot use reference internal when there is no parent"
-    ):
-        m.reference_tensor_internal()
-
-    with pytest.raises(RuntimeError, match="Cannot move from a constant reference"):
-        m.move_const_tensor()
-
-    with pytest.raises(
-        RuntimeError, match="Cannot take ownership of a const reference"
-    ):
-        m.take_const_tensor()
-
-    with pytest.raises(
-        RuntimeError,
-        match="Invalid return_value_policy for Eigen Map type, must be either reference or reference_internal",
-    ):
-        m.take_view_tensor()
-
-
-@pytest.mark.parametrize("m", submodules)
-def test_bad_python_to_cpp_casts(m):
-    with pytest.raises(
-        TypeError, match=r"^round_trip_tensor\(\): incompatible function arguments"
-    ):
-        m.round_trip_tensor(np.zeros((2, 3)))
-
-    with pytest.raises(TypeError, match=r"^Cannot cast array data from dtype"):
-        m.round_trip_tensor(np.zeros(dtype=np.str_, shape=(2, 3, 1)))
-
-    with pytest.raises(
-        TypeError,
-        match=r"^round_trip_tensor_noconvert\(\): incompatible function arguments",
-    ):
-        m.round_trip_tensor_noconvert(tensor_ref)
-
-    assert_equal_tensor_ref(
-        m.round_trip_tensor_noconvert(tensor_ref.astype(np.float64))
-    )
-
-    bad_options = "C" if m.needed_options == "F" else "F"
-    # Shape, dtype and the order need to be correct for a TensorMap cast
-    with pytest.raises(
-        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
-    ):
-        m.round_trip_view_tensor(
-            np.zeros((3, 5, 2), dtype=np.float64, order=bad_options)
-        )
-
-    with pytest.raises(
-        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
-    ):
-        m.round_trip_view_tensor(
-            np.zeros((3, 5, 2), dtype=np.float32, order=m.needed_options)
-        )
-
-    with pytest.raises(
-        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
-    ):
-        m.round_trip_view_tensor(
-            np.zeros((3, 5), dtype=np.float64, order=m.needed_options)
-        )
-
-    temp = np.zeros((3, 5, 2), dtype=np.float64, order=m.needed_options)
-    with pytest.raises(
-        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
-    ):
-        m.round_trip_view_tensor(
-            temp[:, ::-1, :],
-        )
-
-    temp = np.zeros((3, 5, 2), dtype=np.float64, order=m.needed_options)
-    temp.setflags(write=False)
-    with pytest.raises(
-        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
-    ):
-        m.round_trip_view_tensor(temp)
-
-
-@pytest.mark.parametrize("m", submodules)
-def test_references_actually_refer(m):
-    a = m.reference_tensor()
-    temp = a[indices]
-    a[indices] = 100
-    assert_equal_tensor_ref(m.copy_const_tensor(), modified=100)
-    a[indices] = temp
-    assert_equal_tensor_ref(m.copy_const_tensor())
-
-    a = m.reference_view_of_tensor()
-    a[indices] = 100
-    assert_equal_tensor_ref(m.copy_const_tensor(), modified=100)
-    a[indices] = temp
-    assert_equal_tensor_ref(m.copy_const_tensor())
-
-
-@pytest.mark.parametrize("m", submodules)
-def test_round_trip(m):
-    assert_equal_tensor_ref(m.round_trip_tensor(tensor_ref))
-
-    with pytest.raises(TypeError, match="^Cannot cast array data from"):
-        assert_equal_tensor_ref(m.round_trip_tensor2(tensor_ref))
-
-    assert_equal_tensor_ref(m.round_trip_tensor2(np.array(tensor_ref, dtype=np.int32)))
-    assert_equal_tensor_ref(m.round_trip_fixed_tensor(tensor_ref))
-    assert_equal_tensor_ref(m.round_trip_aligned_view_tensor(m.reference_tensor()))
-
-    copy = np.array(tensor_ref, dtype=np.float64, order=m.needed_options)
-    assert_equal_tensor_ref(m.round_trip_view_tensor(copy))
-    assert_equal_tensor_ref(m.round_trip_view_tensor_ref(copy))
-    assert_equal_tensor_ref(m.round_trip_view_tensor_ptr(copy))
-    copy.setflags(write=False)
-    assert_equal_tensor_ref(m.round_trip_const_view_tensor(copy))
-
-    np.testing.assert_array_equal(
-        tensor_ref[:, ::-1, :], m.round_trip_tensor(tensor_ref[:, ::-1, :])
-    )
-
-    assert m.round_trip_rank_0(np.float64(3.5)) == 3.5
-    assert m.round_trip_rank_0(3.5) == 3.5
-
-    with pytest.raises(
-        TypeError,
-        match=r"^round_trip_rank_0_noconvert\(\): incompatible function arguments",
-    ):
-        m.round_trip_rank_0_noconvert(np.float64(3.5))
-
-    with pytest.raises(
-        TypeError,
-        match=r"^round_trip_rank_0_noconvert\(\): incompatible function arguments",
-    ):
-        m.round_trip_rank_0_noconvert(3.5)
-
-    with pytest.raises(
-        TypeError, match=r"^round_trip_rank_0_view\(\): incompatible function arguments"
-    ):
-        m.round_trip_rank_0_view(np.float64(3.5))
-
-    with pytest.raises(
-        TypeError, match=r"^round_trip_rank_0_view\(\): incompatible function arguments"
-    ):
-        m.round_trip_rank_0_view(3.5)
-
-
-@pytest.mark.parametrize("m", submodules)
-def test_round_trip_references_actually_refer(m):
-    # Need to create a copy that matches the type on the C side
-    copy = np.array(tensor_ref, dtype=np.float64, order=m.needed_options)
-    a = m.round_trip_view_tensor(copy)
-    temp = a[indices]
-    a[indices] = 100
-    assert_equal_tensor_ref(copy, modified=100)
-    a[indices] = temp
-    assert_equal_tensor_ref(copy)
-
-
-@pytest.mark.parametrize("m", submodules)
-def test_doc_string(m, doc):
-    assert (
-        doc(m.copy_tensor) == "copy_tensor() -> numpy.ndarray[numpy.float64[?, ?, ?]]"
-    )
-    assert (
-        doc(m.copy_fixed_tensor)
-        == "copy_fixed_tensor() -> numpy.ndarray[numpy.float64[3, 5, 2]]"
-    )
-    assert (
-        doc(m.reference_const_tensor)
-        == "reference_const_tensor() -> numpy.ndarray[numpy.float64[?, ?, ?]]"
-    )
-
-    order_flag = f"flags.{m.needed_options.lower()}_contiguous"
-    assert doc(m.round_trip_view_tensor) == (
-        f"round_trip_view_tensor(arg0: numpy.ndarray[numpy.float64[?, ?, ?], flags.writeable, {order_flag}])"
-        f" -> numpy.ndarray[numpy.float64[?, ?, ?], flags.writeable, {order_flag}]"
-    )
-    assert doc(m.round_trip_const_view_tensor) == (
-        f"round_trip_const_view_tensor(arg0: numpy.ndarray[numpy.float64[?, ?, ?], {order_flag}])"
-        " -> numpy.ndarray[numpy.float64[?, ?, ?]]"
-    )
+import sys
+
+import pytest
+
+np = pytest.importorskip("numpy")
+eigen_tensor = pytest.importorskip("pybind11_tests.eigen_tensor")
+submodules = [eigen_tensor.c_style, eigen_tensor.f_style]
+try:
+    import eigen_tensor_avoid_stl_array as avoid
+
+    submodules += [avoid.c_style, avoid.f_style]
+except ImportError as e:
+    # Ensure config, build, toolchain, etc. issues are not masked here:
+    msg = (
+        "import eigen_tensor_avoid_stl_array FAILED, while "
+        "import pybind11_tests.eigen_tensor succeeded. "
+        "Please ensure that "
+        "test_eigen_tensor.cpp & "
+        "eigen_tensor_avoid_stl_array.cpp "
+        "are built together (or both are not built if Eigen is not available)."
+    )
+    raise RuntimeError(msg) from e
+
+tensor_ref = np.empty((3, 5, 2), dtype=np.int64)
+
+for i in range(tensor_ref.shape[0]):
+    for j in range(tensor_ref.shape[1]):
+        for k in range(tensor_ref.shape[2]):
+            tensor_ref[i, j, k] = i * (5 * 2) + j * 2 + k
+
+indices = (2, 3, 1)
+
+
+@pytest.fixture(autouse=True)
+def cleanup():
+    for module in submodules:
+        module.setup()
+
+    yield
+
+    for module in submodules:
+        assert module.is_ok()
+
+
+def test_import_avoid_stl_array():
+    pytest.importorskip("eigen_tensor_avoid_stl_array")
+    assert len(submodules) == 4
+
+
+def assert_equal_tensor_ref(mat, writeable=True, modified=None):
+    assert mat.flags.writeable == writeable
+
+    copy = np.array(tensor_ref)
+    if modified is not None:
+        copy[indices] = modified
+
+    np.testing.assert_array_equal(mat, copy)
+
+
+@pytest.mark.parametrize("m", submodules)
+@pytest.mark.parametrize("member_name", ["member", "member_view"])
+def test_reference_internal(m, member_name):
+    if not hasattr(sys, "getrefcount"):
+        pytest.skip("No reference counting")
+    foo = m.CustomExample()
+    counts = sys.getrefcount(foo)
+    mem = getattr(foo, member_name)
+    assert_equal_tensor_ref(mem, writeable=False)
+    new_counts = sys.getrefcount(foo)
+    assert new_counts == counts + 1
+    assert_equal_tensor_ref(mem, writeable=False)
+    del mem
+    assert sys.getrefcount(foo) == counts
+
+
+assert_equal_funcs = [
+    "copy_tensor",
+    "copy_fixed_tensor",
+    "copy_const_tensor",
+    "move_tensor_copy",
+    "move_fixed_tensor_copy",
+    "take_tensor",
+    "take_fixed_tensor",
+    "reference_tensor",
+    "reference_tensor_v2",
+    "reference_fixed_tensor",
+    "reference_view_of_tensor",
+    "reference_view_of_tensor_v3",
+    "reference_view_of_tensor_v5",
+    "reference_view_of_fixed_tensor",
+]
+
+assert_equal_const_funcs = [
+    "reference_view_of_tensor_v2",
+    "reference_view_of_tensor_v4",
+    "reference_view_of_tensor_v6",
+    "reference_const_tensor",
+    "reference_const_tensor_v2",
+]
+
+
+@pytest.mark.parametrize("m", submodules)
+@pytest.mark.parametrize("func_name", assert_equal_funcs + assert_equal_const_funcs)
+def test_convert_tensor_to_py(m, func_name):
+    writeable = func_name in assert_equal_funcs
+    assert_equal_tensor_ref(getattr(m, func_name)(), writeable=writeable)
+
+
+@pytest.mark.parametrize("m", submodules)
+def test_bad_cpp_to_python_casts(m):
+    with pytest.raises(
+        RuntimeError, match="Cannot use reference internal when there is no parent"
+    ):
+        m.reference_tensor_internal()
+
+    with pytest.raises(RuntimeError, match="Cannot move from a constant reference"):
+        m.move_const_tensor()
+
+    with pytest.raises(
+        RuntimeError, match="Cannot take ownership of a const reference"
+    ):
+        m.take_const_tensor()
+
+    with pytest.raises(
+        RuntimeError,
+        match="Invalid return_value_policy for Eigen Map type, must be either reference or reference_internal",
+    ):
+        m.take_view_tensor()
+
+
+@pytest.mark.parametrize("m", submodules)
+def test_bad_python_to_cpp_casts(m):
+    with pytest.raises(
+        TypeError, match=r"^round_trip_tensor\(\): incompatible function arguments"
+    ):
+        m.round_trip_tensor(np.zeros((2, 3)))
+
+    with pytest.raises(TypeError, match=r"^Cannot cast array data from dtype"):
+        m.round_trip_tensor(np.zeros(dtype=np.str_, shape=(2, 3, 1)))
+
+    with pytest.raises(
+        TypeError,
+        match=r"^round_trip_tensor_noconvert\(\): incompatible function arguments",
+    ):
+        m.round_trip_tensor_noconvert(tensor_ref)
+
+    assert_equal_tensor_ref(
+        m.round_trip_tensor_noconvert(tensor_ref.astype(np.float64))
+    )
+
+    bad_options = "C" if m.needed_options == "F" else "F"
+    # Shape, dtype and the order need to be correct for a TensorMap cast
+    with pytest.raises(
+        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
+    ):
+        m.round_trip_view_tensor(
+            np.zeros((3, 5, 2), dtype=np.float64, order=bad_options)
+        )
+
+    with pytest.raises(
+        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
+    ):
+        m.round_trip_view_tensor(
+            np.zeros((3, 5, 2), dtype=np.float32, order=m.needed_options)
+        )
+
+    with pytest.raises(
+        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
+    ):
+        m.round_trip_view_tensor(
+            np.zeros((3, 5), dtype=np.float64, order=m.needed_options)
+        )
+
+    temp = np.zeros((3, 5, 2), dtype=np.float64, order=m.needed_options)
+    with pytest.raises(
+        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
+    ):
+        m.round_trip_view_tensor(
+            temp[:, ::-1, :],
+        )
+
+    temp = np.zeros((3, 5, 2), dtype=np.float64, order=m.needed_options)
+    temp.setflags(write=False)
+    with pytest.raises(
+        TypeError, match=r"^round_trip_view_tensor\(\): incompatible function arguments"
+    ):
+        m.round_trip_view_tensor(temp)
+
+
+@pytest.mark.parametrize("m", submodules)
+def test_references_actually_refer(m):
+    a = m.reference_tensor()
+    temp = a[indices]
+    a[indices] = 100
+    assert_equal_tensor_ref(m.copy_const_tensor(), modified=100)
+    a[indices] = temp
+    assert_equal_tensor_ref(m.copy_const_tensor())
+
+    a = m.reference_view_of_tensor()
+    a[indices] = 100
+    assert_equal_tensor_ref(m.copy_const_tensor(), modified=100)
+    a[indices] = temp
+    assert_equal_tensor_ref(m.copy_const_tensor())
+
+
+@pytest.mark.parametrize("m", submodules)
+def test_round_trip(m):
+    assert_equal_tensor_ref(m.round_trip_tensor(tensor_ref))
+
+    with pytest.raises(TypeError, match="^Cannot cast array data from"):
+        assert_equal_tensor_ref(m.round_trip_tensor2(tensor_ref))
+
+    assert_equal_tensor_ref(m.round_trip_tensor2(np.array(tensor_ref, dtype=np.int32)))
+    assert_equal_tensor_ref(m.round_trip_fixed_tensor(tensor_ref))
+    assert_equal_tensor_ref(m.round_trip_aligned_view_tensor(m.reference_tensor()))
+
+    copy = np.array(tensor_ref, dtype=np.float64, order=m.needed_options)
+    assert_equal_tensor_ref(m.round_trip_view_tensor(copy))
+    assert_equal_tensor_ref(m.round_trip_view_tensor_ref(copy))
+    assert_equal_tensor_ref(m.round_trip_view_tensor_ptr(copy))
+    copy.setflags(write=False)
+    assert_equal_tensor_ref(m.round_trip_const_view_tensor(copy))
+
+    np.testing.assert_array_equal(
+        tensor_ref[:, ::-1, :], m.round_trip_tensor(tensor_ref[:, ::-1, :])
+    )
+
+    assert m.round_trip_rank_0(np.float64(3.5)) == 3.5
+    assert m.round_trip_rank_0(3.5) == 3.5
+
+    with pytest.raises(
+        TypeError,
+        match=r"^round_trip_rank_0_noconvert\(\): incompatible function arguments",
+    ):
+        m.round_trip_rank_0_noconvert(np.float64(3.5))
+
+    with pytest.raises(
+        TypeError,
+        match=r"^round_trip_rank_0_noconvert\(\): incompatible function arguments",
+    ):
+        m.round_trip_rank_0_noconvert(3.5)
+
+    with pytest.raises(
+        TypeError, match=r"^round_trip_rank_0_view\(\): incompatible function arguments"
+    ):
+        m.round_trip_rank_0_view(np.float64(3.5))
+
+    with pytest.raises(
+        TypeError, match=r"^round_trip_rank_0_view\(\): incompatible function arguments"
+    ):
+        m.round_trip_rank_0_view(3.5)
+
+
+@pytest.mark.parametrize("m", submodules)
+def test_round_trip_references_actually_refer(m):
+    # Need to create a copy that matches the type on the C side
+    copy = np.array(tensor_ref, dtype=np.float64, order=m.needed_options)
+    a = m.round_trip_view_tensor(copy)
+    temp = a[indices]
+    a[indices] = 100
+    assert_equal_tensor_ref(copy, modified=100)
+    a[indices] = temp
+    assert_equal_tensor_ref(copy)
+
+
+@pytest.mark.parametrize("m", submodules)
+def test_doc_string(m, doc):
+    assert (
+        doc(m.copy_tensor) == "copy_tensor() -> numpy.ndarray[numpy.float64[?, ?, ?]]"
+    )
+    assert (
+        doc(m.copy_fixed_tensor)
+        == "copy_fixed_tensor() -> numpy.ndarray[numpy.float64[3, 5, 2]]"
+    )
+    assert (
+        doc(m.reference_const_tensor)
+        == "reference_const_tensor() -> numpy.ndarray[numpy.float64[?, ?, ?]]"
+    )
+
+    order_flag = f"flags.{m.needed_options.lower()}_contiguous"
+    assert doc(m.round_trip_view_tensor) == (
+        f"round_trip_view_tensor(arg0: numpy.ndarray[numpy.float64[?, ?, ?], flags.writeable, {order_flag}])"
+        f" -> numpy.ndarray[numpy.float64[?, ?, ?], flags.writeable, {order_flag}]"
+    )
+    assert doc(m.round_trip_const_view_tensor) == (
+        f"round_trip_const_view_tensor(arg0: numpy.ndarray[numpy.float64[?, ?, ?], {order_flag}])"
+        " -> numpy.ndarray[numpy.float64[?, ?, ?]]"
+    )

third_party/CityFlow/extern/pybind11/tests/test_enum.cpp

@@ -1,133 +1,133 @@
-/*
-    tests/test_enums.cpp -- enumerations
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-TEST_SUBMODULE(enums, m) {
-    // test_unscoped_enum
-    enum UnscopedEnum { EOne = 1, ETwo, EThree };
-    py::enum_<UnscopedEnum>(m, "UnscopedEnum", py::arithmetic(), "An unscoped enumeration")
-        .value("EOne", EOne, "Docstring for EOne")
-        .value("ETwo", ETwo, "Docstring for ETwo")
-        .value("EThree", EThree, "Docstring for EThree")
-        .export_values();
-
-    // test_scoped_enum
-    enum class ScopedEnum { Two = 2, Three };
-    py::enum_<ScopedEnum>(m, "ScopedEnum", py::arithmetic())
-        .value("Two", ScopedEnum::Two)
-        .value("Three", ScopedEnum::Three);
-
-    m.def("test_scoped_enum", [](ScopedEnum z) {
-        return "ScopedEnum::" + std::string(z == ScopedEnum::Two ? "Two" : "Three");
-    });
-
-    // test_binary_operators
-    enum Flags { Read = 4, Write = 2, Execute = 1 };
-    py::enum_<Flags>(m, "Flags", py::arithmetic())
-        .value("Read", Flags::Read)
-        .value("Write", Flags::Write)
-        .value("Execute", Flags::Execute)
-        .export_values();
-
-    // test_implicit_conversion
-    class ClassWithUnscopedEnum {
-    public:
-        enum EMode { EFirstMode = 1, ESecondMode };
-
-        static EMode test_function(EMode mode) { return mode; }
-    };
-    py::class_<ClassWithUnscopedEnum> exenum_class(m, "ClassWithUnscopedEnum");
-    exenum_class.def_static("test_function", &ClassWithUnscopedEnum::test_function);
-    py::enum_<ClassWithUnscopedEnum::EMode>(exenum_class, "EMode")
-        .value("EFirstMode", ClassWithUnscopedEnum::EFirstMode)
-        .value("ESecondMode", ClassWithUnscopedEnum::ESecondMode)
-        .export_values();
-
-    // test_enum_to_int
-    m.def("test_enum_to_int", [](int) {});
-    m.def("test_enum_to_uint", [](uint32_t) {});
-    m.def("test_enum_to_long_long", [](long long) {});
-
-    // test_duplicate_enum_name
-    enum SimpleEnum { ONE, TWO, THREE };
-
-    m.def("register_bad_enum", [m]() {
-        py::enum_<SimpleEnum>(m, "SimpleEnum")
-            .value("ONE", SimpleEnum::ONE) // NOTE: all value function calls are called with the
-                                           // same first parameter value
-            .value("ONE", SimpleEnum::TWO)
-            .value("ONE", SimpleEnum::THREE)
-            .export_values();
-    });
-
-    // test_enum_scalar
-    enum UnscopedUCharEnum : unsigned char {};
-    enum class ScopedShortEnum : short {};
-    enum class ScopedLongEnum : long {};
-    enum UnscopedUInt64Enum : std::uint64_t {};
-    static_assert(
-        py::detail::all_of<
-            std::is_same<py::enum_<UnscopedUCharEnum>::Scalar, unsigned char>,
-            std::is_same<py::enum_<ScopedShortEnum>::Scalar, short>,
-            std::is_same<py::enum_<ScopedLongEnum>::Scalar, long>,
-            std::is_same<py::enum_<UnscopedUInt64Enum>::Scalar, std::uint64_t>>::value,
-        "Error during the deduction of enum's scalar type with normal integer underlying");
-
-    // test_enum_scalar_with_char_underlying
-    enum class ScopedCharEnum : char { Zero, Positive };
-    enum class ScopedWCharEnum : wchar_t { Zero, Positive };
-    enum class ScopedChar32Enum : char32_t { Zero, Positive };
-    enum class ScopedChar16Enum : char16_t { Zero, Positive };
-
-    // test the scalar of char type enums according to chapter 'Character types'
-    // from https://en.cppreference.com/w/cpp/language/types
-    static_assert(
-        py::detail::any_of<
-            std::is_same<py::enum_<ScopedCharEnum>::Scalar, signed char>,  // e.g. gcc on x86
-            std::is_same<py::enum_<ScopedCharEnum>::Scalar, unsigned char> // e.g. arm linux
-            >::value,
-        "char should be cast to either signed char or unsigned char");
-    static_assert(sizeof(py::enum_<ScopedWCharEnum>::Scalar) == 2
-                      || sizeof(py::enum_<ScopedWCharEnum>::Scalar) == 4,
-                  "wchar_t should be either 16 bits (Windows) or 32 (everywhere else)");
-    static_assert(
-        py::detail::all_of<
-            std::is_same<py::enum_<ScopedChar32Enum>::Scalar, std::uint_least32_t>,
-            std::is_same<py::enum_<ScopedChar16Enum>::Scalar, std::uint_least16_t>>::value,
-        "char32_t, char16_t (and char8_t)'s size, signedness, and alignment is determined");
-#if defined(PYBIND11_HAS_U8STRING)
-    enum class ScopedChar8Enum : char8_t { Zero, Positive };
-    static_assert(std::is_same<py::enum_<ScopedChar8Enum>::Scalar, unsigned char>::value);
-#endif
-
-    // test_char_underlying_enum
-    py::enum_<ScopedCharEnum>(m, "ScopedCharEnum")
-        .value("Zero", ScopedCharEnum::Zero)
-        .value("Positive", ScopedCharEnum::Positive);
-    py::enum_<ScopedWCharEnum>(m, "ScopedWCharEnum")
-        .value("Zero", ScopedWCharEnum::Zero)
-        .value("Positive", ScopedWCharEnum::Positive);
-    py::enum_<ScopedChar32Enum>(m, "ScopedChar32Enum")
-        .value("Zero", ScopedChar32Enum::Zero)
-        .value("Positive", ScopedChar32Enum::Positive);
-    py::enum_<ScopedChar16Enum>(m, "ScopedChar16Enum")
-        .value("Zero", ScopedChar16Enum::Zero)
-        .value("Positive", ScopedChar16Enum::Positive);
-
-    // test_bool_underlying_enum
-    enum class ScopedBoolEnum : bool { FALSE, TRUE };
-
-    // bool is unsigned (std::is_signed returns false) and 1-byte long, so represented with u8
-    static_assert(std::is_same<py::enum_<ScopedBoolEnum>::Scalar, std::uint8_t>::value, "");
-
-    py::enum_<ScopedBoolEnum>(m, "ScopedBoolEnum")
-        .value("FALSE", ScopedBoolEnum::FALSE)
-        .value("TRUE", ScopedBoolEnum::TRUE);
-}
+/*
+    tests/test_enums.cpp -- enumerations
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "pybind11_tests.h"
+
+TEST_SUBMODULE(enums, m) {
+    // test_unscoped_enum
+    enum UnscopedEnum { EOne = 1, ETwo, EThree };
+    py::enum_<UnscopedEnum>(m, "UnscopedEnum", py::arithmetic(), "An unscoped enumeration")
+        .value("EOne", EOne, "Docstring for EOne")
+        .value("ETwo", ETwo, "Docstring for ETwo")
+        .value("EThree", EThree, "Docstring for EThree")
+        .export_values();
+
+    // test_scoped_enum
+    enum class ScopedEnum { Two = 2, Three };
+    py::enum_<ScopedEnum>(m, "ScopedEnum", py::arithmetic())
+        .value("Two", ScopedEnum::Two)
+        .value("Three", ScopedEnum::Three);
+
+    m.def("test_scoped_enum", [](ScopedEnum z) {
+        return "ScopedEnum::" + std::string(z == ScopedEnum::Two ? "Two" : "Three");
+    });
+
+    // test_binary_operators
+    enum Flags { Read = 4, Write = 2, Execute = 1 };
+    py::enum_<Flags>(m, "Flags", py::arithmetic())
+        .value("Read", Flags::Read)
+        .value("Write", Flags::Write)
+        .value("Execute", Flags::Execute)
+        .export_values();
+
+    // test_implicit_conversion
+    class ClassWithUnscopedEnum {
+    public:
+        enum EMode { EFirstMode = 1, ESecondMode };
+
+        static EMode test_function(EMode mode) { return mode; }
+    };
+    py::class_<ClassWithUnscopedEnum> exenum_class(m, "ClassWithUnscopedEnum");
+    exenum_class.def_static("test_function", &ClassWithUnscopedEnum::test_function);
+    py::enum_<ClassWithUnscopedEnum::EMode>(exenum_class, "EMode")
+        .value("EFirstMode", ClassWithUnscopedEnum::EFirstMode)
+        .value("ESecondMode", ClassWithUnscopedEnum::ESecondMode)
+        .export_values();
+
+    // test_enum_to_int
+    m.def("test_enum_to_int", [](int) {});
+    m.def("test_enum_to_uint", [](uint32_t) {});
+    m.def("test_enum_to_long_long", [](long long) {});
+
+    // test_duplicate_enum_name
+    enum SimpleEnum { ONE, TWO, THREE };
+
+    m.def("register_bad_enum", [m]() {
+        py::enum_<SimpleEnum>(m, "SimpleEnum")
+            .value("ONE", SimpleEnum::ONE) // NOTE: all value function calls are called with the
+                                           // same first parameter value
+            .value("ONE", SimpleEnum::TWO)
+            .value("ONE", SimpleEnum::THREE)
+            .export_values();
+    });
+
+    // test_enum_scalar
+    enum UnscopedUCharEnum : unsigned char {};
+    enum class ScopedShortEnum : short {};
+    enum class ScopedLongEnum : long {};
+    enum UnscopedUInt64Enum : std::uint64_t {};
+    static_assert(
+        py::detail::all_of<
+            std::is_same<py::enum_<UnscopedUCharEnum>::Scalar, unsigned char>,
+            std::is_same<py::enum_<ScopedShortEnum>::Scalar, short>,
+            std::is_same<py::enum_<ScopedLongEnum>::Scalar, long>,
+            std::is_same<py::enum_<UnscopedUInt64Enum>::Scalar, std::uint64_t>>::value,
+        "Error during the deduction of enum's scalar type with normal integer underlying");
+
+    // test_enum_scalar_with_char_underlying
+    enum class ScopedCharEnum : char { Zero, Positive };
+    enum class ScopedWCharEnum : wchar_t { Zero, Positive };
+    enum class ScopedChar32Enum : char32_t { Zero, Positive };
+    enum class ScopedChar16Enum : char16_t { Zero, Positive };
+
+    // test the scalar of char type enums according to chapter 'Character types'
+    // from https://en.cppreference.com/w/cpp/language/types
+    static_assert(
+        py::detail::any_of<
+            std::is_same<py::enum_<ScopedCharEnum>::Scalar, signed char>,  // e.g. gcc on x86
+            std::is_same<py::enum_<ScopedCharEnum>::Scalar, unsigned char> // e.g. arm linux
+            >::value,
+        "char should be cast to either signed char or unsigned char");
+    static_assert(sizeof(py::enum_<ScopedWCharEnum>::Scalar) == 2
+                      || sizeof(py::enum_<ScopedWCharEnum>::Scalar) == 4,
+                  "wchar_t should be either 16 bits (Windows) or 32 (everywhere else)");
+    static_assert(
+        py::detail::all_of<
+            std::is_same<py::enum_<ScopedChar32Enum>::Scalar, std::uint_least32_t>,
+            std::is_same<py::enum_<ScopedChar16Enum>::Scalar, std::uint_least16_t>>::value,
+        "char32_t, char16_t (and char8_t)'s size, signedness, and alignment is determined");
+#if defined(PYBIND11_HAS_U8STRING)
+    enum class ScopedChar8Enum : char8_t { Zero, Positive };
+    static_assert(std::is_same<py::enum_<ScopedChar8Enum>::Scalar, unsigned char>::value);
+#endif
+
+    // test_char_underlying_enum
+    py::enum_<ScopedCharEnum>(m, "ScopedCharEnum")
+        .value("Zero", ScopedCharEnum::Zero)
+        .value("Positive", ScopedCharEnum::Positive);
+    py::enum_<ScopedWCharEnum>(m, "ScopedWCharEnum")
+        .value("Zero", ScopedWCharEnum::Zero)
+        .value("Positive", ScopedWCharEnum::Positive);
+    py::enum_<ScopedChar32Enum>(m, "ScopedChar32Enum")
+        .value("Zero", ScopedChar32Enum::Zero)
+        .value("Positive", ScopedChar32Enum::Positive);
+    py::enum_<ScopedChar16Enum>(m, "ScopedChar16Enum")
+        .value("Zero", ScopedChar16Enum::Zero)
+        .value("Positive", ScopedChar16Enum::Positive);
+
+    // test_bool_underlying_enum
+    enum class ScopedBoolEnum : bool { FALSE, TRUE };
+
+    // bool is unsigned (std::is_signed returns false) and 1-byte long, so represented with u8
+    static_assert(std::is_same<py::enum_<ScopedBoolEnum>::Scalar, std::uint8_t>::value, "");
+
+    py::enum_<ScopedBoolEnum>(m, "ScopedBoolEnum")
+        .value("FALSE", ScopedBoolEnum::FALSE)
+        .value("TRUE", ScopedBoolEnum::TRUE);
+}

third_party/CityFlow/extern/pybind11/tests/test_enum.py

@@ -1,269 +1,269 @@
-# ruff: noqa: SIM201 SIM300 SIM202
-
-import pytest
-
-from pybind11_tests import enums as m
-
-
-def test_unscoped_enum():
-    assert str(m.UnscopedEnum.EOne) == "UnscopedEnum.EOne"
-    assert str(m.UnscopedEnum.ETwo) == "UnscopedEnum.ETwo"
-    assert str(m.EOne) == "UnscopedEnum.EOne"
-    assert repr(m.UnscopedEnum.EOne) == "<UnscopedEnum.EOne: 1>"
-    assert repr(m.UnscopedEnum.ETwo) == "<UnscopedEnum.ETwo: 2>"
-    assert repr(m.EOne) == "<UnscopedEnum.EOne: 1>"
-
-    # name property
-    assert m.UnscopedEnum.EOne.name == "EOne"
-    assert m.UnscopedEnum.EOne.value == 1
-    assert m.UnscopedEnum.ETwo.name == "ETwo"
-    assert m.UnscopedEnum.ETwo.value == 2
-    assert m.EOne is m.UnscopedEnum.EOne
-    # name, value readonly
-    with pytest.raises(AttributeError):
-        m.UnscopedEnum.EOne.name = ""
-    with pytest.raises(AttributeError):
-        m.UnscopedEnum.EOne.value = 10
-    # name, value returns a copy
-    # TODO: Neither the name nor value tests actually check against aliasing.
-    # Use a mutable type that has reference semantics.
-    nonaliased_name = m.UnscopedEnum.EOne.name
-    nonaliased_name = "bar"  # noqa: F841
-    assert m.UnscopedEnum.EOne.name == "EOne"
-    nonaliased_value = m.UnscopedEnum.EOne.value
-    nonaliased_value = 10  # noqa: F841
-    assert m.UnscopedEnum.EOne.value == 1
-
-    # __members__ property
-    assert m.UnscopedEnum.__members__ == {
-        "EOne": m.UnscopedEnum.EOne,
-        "ETwo": m.UnscopedEnum.ETwo,
-        "EThree": m.UnscopedEnum.EThree,
-    }
-    # __members__ readonly
-    with pytest.raises(AttributeError):
-        m.UnscopedEnum.__members__ = {}
-    # __members__ returns a copy
-    nonaliased_members = m.UnscopedEnum.__members__
-    nonaliased_members["bar"] = "baz"
-    assert m.UnscopedEnum.__members__ == {
-        "EOne": m.UnscopedEnum.EOne,
-        "ETwo": m.UnscopedEnum.ETwo,
-        "EThree": m.UnscopedEnum.EThree,
-    }
-
-    for docstring_line in """An unscoped enumeration
-
-Members:
-
-  EOne : Docstring for EOne
-
-  ETwo : Docstring for ETwo
-
-  EThree : Docstring for EThree""".split("\n"):
-        assert docstring_line in m.UnscopedEnum.__doc__
-
-    # Unscoped enums will accept ==/!= int comparisons
-    y = m.UnscopedEnum.ETwo
-    assert y == 2
-    assert 2 == y
-    assert y != 3
-    assert 3 != y
-    # Compare with None
-    assert y != None  # noqa: E711
-    assert not (y == None)  # noqa: E711
-    # Compare with an object
-    assert y != object()
-    assert not (y == object())
-    # Compare with string
-    assert y != "2"
-    assert "2" != y
-    assert not ("2" == y)
-    assert not (y == "2")
-
-    with pytest.raises(TypeError):
-        y < object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y <= object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y > object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y >= object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y | object()
-
-    with pytest.raises(TypeError):
-        y & object()
-
-    with pytest.raises(TypeError):
-        y ^ object()
-
-    assert int(m.UnscopedEnum.ETwo) == 2
-    assert str(m.UnscopedEnum(2)) == "UnscopedEnum.ETwo"
-
-    # order
-    assert m.UnscopedEnum.EOne < m.UnscopedEnum.ETwo
-    assert m.UnscopedEnum.EOne < 2
-    assert m.UnscopedEnum.ETwo > m.UnscopedEnum.EOne
-    assert m.UnscopedEnum.ETwo > 1
-    assert m.UnscopedEnum.ETwo <= 2
-    assert m.UnscopedEnum.ETwo >= 2
-    assert m.UnscopedEnum.EOne <= m.UnscopedEnum.ETwo
-    assert m.UnscopedEnum.EOne <= 2
-    assert m.UnscopedEnum.ETwo >= m.UnscopedEnum.EOne
-    assert m.UnscopedEnum.ETwo >= 1
-    assert not (m.UnscopedEnum.ETwo < m.UnscopedEnum.EOne)
-    assert not (2 < m.UnscopedEnum.EOne)
-
-    # arithmetic
-    assert m.UnscopedEnum.EOne & m.UnscopedEnum.EThree == m.UnscopedEnum.EOne
-    assert m.UnscopedEnum.EOne | m.UnscopedEnum.ETwo == m.UnscopedEnum.EThree
-    assert m.UnscopedEnum.EOne ^ m.UnscopedEnum.EThree == m.UnscopedEnum.ETwo
-
-
-def test_scoped_enum():
-    assert m.test_scoped_enum(m.ScopedEnum.Three) == "ScopedEnum::Three"
-    z = m.ScopedEnum.Two
-    assert m.test_scoped_enum(z) == "ScopedEnum::Two"
-
-    # Scoped enums will *NOT* accept ==/!= int comparisons (Will always return False)
-    assert not z == 3
-    assert not 3 == z
-    assert z != 3
-    assert 3 != z
-    # Compare with None
-    assert z != None  # noqa: E711
-    assert not (z == None)  # noqa: E711
-    # Compare with an object
-    assert z != object()
-    assert not (z == object())
-    # Scoped enums will *NOT* accept >, <, >= and <= int comparisons (Will throw exceptions)
-    with pytest.raises(TypeError):
-        z > 3  # noqa: B015
-    with pytest.raises(TypeError):
-        z < 3  # noqa: B015
-    with pytest.raises(TypeError):
-        z >= 3  # noqa: B015
-    with pytest.raises(TypeError):
-        z <= 3  # noqa: B015
-
-    # order
-    assert m.ScopedEnum.Two < m.ScopedEnum.Three
-    assert m.ScopedEnum.Three > m.ScopedEnum.Two
-    assert m.ScopedEnum.Two <= m.ScopedEnum.Three
-    assert m.ScopedEnum.Two <= m.ScopedEnum.Two
-    assert m.ScopedEnum.Two >= m.ScopedEnum.Two
-    assert m.ScopedEnum.Three >= m.ScopedEnum.Two
-
-
-def test_implicit_conversion():
-    assert str(m.ClassWithUnscopedEnum.EMode.EFirstMode) == "EMode.EFirstMode"
-    assert str(m.ClassWithUnscopedEnum.EFirstMode) == "EMode.EFirstMode"
-    assert repr(m.ClassWithUnscopedEnum.EMode.EFirstMode) == "<EMode.EFirstMode: 1>"
-    assert repr(m.ClassWithUnscopedEnum.EFirstMode) == "<EMode.EFirstMode: 1>"
-
-    f = m.ClassWithUnscopedEnum.test_function
-    first = m.ClassWithUnscopedEnum.EFirstMode
-    second = m.ClassWithUnscopedEnum.ESecondMode
-
-    assert f(first) == 1
-
-    assert f(first) == f(first)
-    assert not f(first) != f(first)
-
-    assert f(first) != f(second)
-    assert not f(first) == f(second)
-
-    assert f(first) == int(f(first))
-    assert not f(first) != int(f(first))
-
-    assert f(first) != int(f(second))
-    assert not f(first) == int(f(second))
-
-    # noinspection PyDictCreation
-    x = {f(first): 1, f(second): 2}
-    x[f(first)] = 3
-    x[f(second)] = 4
-    # Hashing test
-    assert repr(x) == "{<EMode.EFirstMode: 1>: 3, <EMode.ESecondMode: 2>: 4}"
-
-
-def test_binary_operators():
-    assert int(m.Flags.Read) == 4
-    assert int(m.Flags.Write) == 2
-    assert int(m.Flags.Execute) == 1
-    assert int(m.Flags.Read | m.Flags.Write | m.Flags.Execute) == 7
-    assert int(m.Flags.Read | m.Flags.Write) == 6
-    assert int(m.Flags.Read | m.Flags.Execute) == 5
-    assert int(m.Flags.Write | m.Flags.Execute) == 3
-    assert int(m.Flags.Write | 1) == 3
-    assert ~m.Flags.Write == -3
-
-    state = m.Flags.Read | m.Flags.Write
-    assert (state & m.Flags.Read) != 0
-    assert (state & m.Flags.Write) != 0
-    assert (state & m.Flags.Execute) == 0
-    assert (state & 1) == 0
-
-    state2 = ~state
-    assert state2 == -7
-    assert int(state ^ state2) == -1
-
-
-def test_enum_to_int():
-    m.test_enum_to_int(m.Flags.Read)
-    m.test_enum_to_int(m.ClassWithUnscopedEnum.EMode.EFirstMode)
-    m.test_enum_to_int(m.ScopedCharEnum.Positive)
-    m.test_enum_to_int(m.ScopedBoolEnum.TRUE)
-    m.test_enum_to_uint(m.Flags.Read)
-    m.test_enum_to_uint(m.ClassWithUnscopedEnum.EMode.EFirstMode)
-    m.test_enum_to_uint(m.ScopedCharEnum.Positive)
-    m.test_enum_to_uint(m.ScopedBoolEnum.TRUE)
-    m.test_enum_to_long_long(m.Flags.Read)
-    m.test_enum_to_long_long(m.ClassWithUnscopedEnum.EMode.EFirstMode)
-    m.test_enum_to_long_long(m.ScopedCharEnum.Positive)
-    m.test_enum_to_long_long(m.ScopedBoolEnum.TRUE)
-
-
-def test_duplicate_enum_name():
-    with pytest.raises(ValueError) as excinfo:
-        m.register_bad_enum()
-    assert str(excinfo.value) == 'SimpleEnum: element "ONE" already exists!'
-
-
-def test_char_underlying_enum():  # Issue #1331/PR #1334:
-    assert type(m.ScopedCharEnum.Positive.__int__()) is int
-    assert int(m.ScopedChar16Enum.Zero) == 0
-    assert hash(m.ScopedChar32Enum.Positive) == 1
-    assert type(m.ScopedCharEnum.Positive.__getstate__()) is int
-    assert m.ScopedWCharEnum(1) == m.ScopedWCharEnum.Positive
-    with pytest.raises(TypeError):
-        # Even if the underlying type is char, only an int can be used to construct the enum:
-        m.ScopedCharEnum("0")
-
-
-def test_bool_underlying_enum():
-    assert type(m.ScopedBoolEnum.TRUE.__int__()) is int
-    assert int(m.ScopedBoolEnum.FALSE) == 0
-    assert hash(m.ScopedBoolEnum.TRUE) == 1
-    assert type(m.ScopedBoolEnum.TRUE.__getstate__()) is int
-    assert m.ScopedBoolEnum(1) == m.ScopedBoolEnum.TRUE
-    # Enum could construct with a bool
-    # (bool is a strict subclass of int, and False will be converted to 0)
-    assert m.ScopedBoolEnum(False) == m.ScopedBoolEnum.FALSE
-
-
-def test_docstring_signatures():
-    for enum_type in [m.ScopedEnum, m.UnscopedEnum]:
-        for attr in enum_type.__dict__.values():
-            # Issue #2623/PR #2637: Add argument names to enum_ methods
-            assert "arg0" not in (attr.__doc__ or "")
-
-
-def test_str_signature():
-    for enum_type in [m.ScopedEnum, m.UnscopedEnum]:
-        assert enum_type.__str__.__doc__.startswith("__str__")
+# ruff: noqa: SIM201 SIM300 SIM202
+
+import pytest
+
+from pybind11_tests import enums as m
+
+
+def test_unscoped_enum():
+    assert str(m.UnscopedEnum.EOne) == "UnscopedEnum.EOne"
+    assert str(m.UnscopedEnum.ETwo) == "UnscopedEnum.ETwo"
+    assert str(m.EOne) == "UnscopedEnum.EOne"
+    assert repr(m.UnscopedEnum.EOne) == "<UnscopedEnum.EOne: 1>"
+    assert repr(m.UnscopedEnum.ETwo) == "<UnscopedEnum.ETwo: 2>"
+    assert repr(m.EOne) == "<UnscopedEnum.EOne: 1>"
+
+    # name property
+    assert m.UnscopedEnum.EOne.name == "EOne"
+    assert m.UnscopedEnum.EOne.value == 1
+    assert m.UnscopedEnum.ETwo.name == "ETwo"
+    assert m.UnscopedEnum.ETwo.value == 2
+    assert m.EOne is m.UnscopedEnum.EOne
+    # name, value readonly
+    with pytest.raises(AttributeError):
+        m.UnscopedEnum.EOne.name = ""
+    with pytest.raises(AttributeError):
+        m.UnscopedEnum.EOne.value = 10
+    # name, value returns a copy
+    # TODO: Neither the name nor value tests actually check against aliasing.
+    # Use a mutable type that has reference semantics.
+    nonaliased_name = m.UnscopedEnum.EOne.name
+    nonaliased_name = "bar"  # noqa: F841
+    assert m.UnscopedEnum.EOne.name == "EOne"
+    nonaliased_value = m.UnscopedEnum.EOne.value
+    nonaliased_value = 10  # noqa: F841
+    assert m.UnscopedEnum.EOne.value == 1
+
+    # __members__ property
+    assert m.UnscopedEnum.__members__ == {
+        "EOne": m.UnscopedEnum.EOne,
+        "ETwo": m.UnscopedEnum.ETwo,
+        "EThree": m.UnscopedEnum.EThree,
+    }
+    # __members__ readonly
+    with pytest.raises(AttributeError):
+        m.UnscopedEnum.__members__ = {}
+    # __members__ returns a copy
+    nonaliased_members = m.UnscopedEnum.__members__
+    nonaliased_members["bar"] = "baz"
+    assert m.UnscopedEnum.__members__ == {
+        "EOne": m.UnscopedEnum.EOne,
+        "ETwo": m.UnscopedEnum.ETwo,
+        "EThree": m.UnscopedEnum.EThree,
+    }
+
+    for docstring_line in """An unscoped enumeration
+
+Members:
+
+  EOne : Docstring for EOne
+
+  ETwo : Docstring for ETwo
+
+  EThree : Docstring for EThree""".split("\n"):
+        assert docstring_line in m.UnscopedEnum.__doc__
+
+    # Unscoped enums will accept ==/!= int comparisons
+    y = m.UnscopedEnum.ETwo
+    assert y == 2
+    assert 2 == y
+    assert y != 3
+    assert 3 != y
+    # Compare with None
+    assert y != None  # noqa: E711
+    assert not (y == None)  # noqa: E711
+    # Compare with an object
+    assert y != object()
+    assert not (y == object())
+    # Compare with string
+    assert y != "2"
+    assert "2" != y
+    assert not ("2" == y)
+    assert not (y == "2")
+
+    with pytest.raises(TypeError):
+        y < object()  # noqa: B015
+
+    with pytest.raises(TypeError):
+        y <= object()  # noqa: B015
+
+    with pytest.raises(TypeError):
+        y > object()  # noqa: B015
+
+    with pytest.raises(TypeError):
+        y >= object()  # noqa: B015
+
+    with pytest.raises(TypeError):
+        y | object()
+
+    with pytest.raises(TypeError):
+        y & object()
+
+    with pytest.raises(TypeError):
+        y ^ object()
+
+    assert int(m.UnscopedEnum.ETwo) == 2
+    assert str(m.UnscopedEnum(2)) == "UnscopedEnum.ETwo"
+
+    # order
+    assert m.UnscopedEnum.EOne < m.UnscopedEnum.ETwo
+    assert m.UnscopedEnum.EOne < 2
+    assert m.UnscopedEnum.ETwo > m.UnscopedEnum.EOne
+    assert m.UnscopedEnum.ETwo > 1
+    assert m.UnscopedEnum.ETwo <= 2
+    assert m.UnscopedEnum.ETwo >= 2
+    assert m.UnscopedEnum.EOne <= m.UnscopedEnum.ETwo
+    assert m.UnscopedEnum.EOne <= 2
+    assert m.UnscopedEnum.ETwo >= m.UnscopedEnum.EOne
+    assert m.UnscopedEnum.ETwo >= 1
+    assert not (m.UnscopedEnum.ETwo < m.UnscopedEnum.EOne)
+    assert not (2 < m.UnscopedEnum.EOne)
+
+    # arithmetic
+    assert m.UnscopedEnum.EOne & m.UnscopedEnum.EThree == m.UnscopedEnum.EOne
+    assert m.UnscopedEnum.EOne | m.UnscopedEnum.ETwo == m.UnscopedEnum.EThree
+    assert m.UnscopedEnum.EOne ^ m.UnscopedEnum.EThree == m.UnscopedEnum.ETwo
+
+
+def test_scoped_enum():
+    assert m.test_scoped_enum(m.ScopedEnum.Three) == "ScopedEnum::Three"
+    z = m.ScopedEnum.Two
+    assert m.test_scoped_enum(z) == "ScopedEnum::Two"
+
+    # Scoped enums will *NOT* accept ==/!= int comparisons (Will always return False)
+    assert not z == 3
+    assert not 3 == z
+    assert z != 3
+    assert 3 != z
+    # Compare with None
+    assert z != None  # noqa: E711
+    assert not (z == None)  # noqa: E711
+    # Compare with an object
+    assert z != object()
+    assert not (z == object())
+    # Scoped enums will *NOT* accept >, <, >= and <= int comparisons (Will throw exceptions)
+    with pytest.raises(TypeError):
+        z > 3  # noqa: B015
+    with pytest.raises(TypeError):
+        z < 3  # noqa: B015
+    with pytest.raises(TypeError):
+        z >= 3  # noqa: B015
+    with pytest.raises(TypeError):
+        z <= 3  # noqa: B015
+
+    # order
+    assert m.ScopedEnum.Two < m.ScopedEnum.Three
+    assert m.ScopedEnum.Three > m.ScopedEnum.Two
+    assert m.ScopedEnum.Two <= m.ScopedEnum.Three
+    assert m.ScopedEnum.Two <= m.ScopedEnum.Two
+    assert m.ScopedEnum.Two >= m.ScopedEnum.Two
+    assert m.ScopedEnum.Three >= m.ScopedEnum.Two
+
+
+def test_implicit_conversion():
+    assert str(m.ClassWithUnscopedEnum.EMode.EFirstMode) == "EMode.EFirstMode"
+    assert str(m.ClassWithUnscopedEnum.EFirstMode) == "EMode.EFirstMode"
+    assert repr(m.ClassWithUnscopedEnum.EMode.EFirstMode) == "<EMode.EFirstMode: 1>"
+    assert repr(m.ClassWithUnscopedEnum.EFirstMode) == "<EMode.EFirstMode: 1>"
+
+    f = m.ClassWithUnscopedEnum.test_function
+    first = m.ClassWithUnscopedEnum.EFirstMode
+    second = m.ClassWithUnscopedEnum.ESecondMode
+
+    assert f(first) == 1
+
+    assert f(first) == f(first)
+    assert not f(first) != f(first)
+
+    assert f(first) != f(second)
+    assert not f(first) == f(second)
+
+    assert f(first) == int(f(first))
+    assert not f(first) != int(f(first))
+
+    assert f(first) != int(f(second))
+    assert not f(first) == int(f(second))
+
+    # noinspection PyDictCreation
+    x = {f(first): 1, f(second): 2}
+    x[f(first)] = 3
+    x[f(second)] = 4
+    # Hashing test
+    assert repr(x) == "{<EMode.EFirstMode: 1>: 3, <EMode.ESecondMode: 2>: 4}"
+
+
+def test_binary_operators():
+    assert int(m.Flags.Read) == 4
+    assert int(m.Flags.Write) == 2
+    assert int(m.Flags.Execute) == 1
+    assert int(m.Flags.Read | m.Flags.Write | m.Flags.Execute) == 7
+    assert int(m.Flags.Read | m.Flags.Write) == 6
+    assert int(m.Flags.Read | m.Flags.Execute) == 5
+    assert int(m.Flags.Write | m.Flags.Execute) == 3
+    assert int(m.Flags.Write | 1) == 3
+    assert ~m.Flags.Write == -3
+
+    state = m.Flags.Read | m.Flags.Write
+    assert (state & m.Flags.Read) != 0
+    assert (state & m.Flags.Write) != 0
+    assert (state & m.Flags.Execute) == 0
+    assert (state & 1) == 0
+
+    state2 = ~state
+    assert state2 == -7
+    assert int(state ^ state2) == -1
+
+
+def test_enum_to_int():
+    m.test_enum_to_int(m.Flags.Read)
+    m.test_enum_to_int(m.ClassWithUnscopedEnum.EMode.EFirstMode)
+    m.test_enum_to_int(m.ScopedCharEnum.Positive)
+    m.test_enum_to_int(m.ScopedBoolEnum.TRUE)
+    m.test_enum_to_uint(m.Flags.Read)
+    m.test_enum_to_uint(m.ClassWithUnscopedEnum.EMode.EFirstMode)
+    m.test_enum_to_uint(m.ScopedCharEnum.Positive)
+    m.test_enum_to_uint(m.ScopedBoolEnum.TRUE)
+    m.test_enum_to_long_long(m.Flags.Read)
+    m.test_enum_to_long_long(m.ClassWithUnscopedEnum.EMode.EFirstMode)
+    m.test_enum_to_long_long(m.ScopedCharEnum.Positive)
+    m.test_enum_to_long_long(m.ScopedBoolEnum.TRUE)
+
+
+def test_duplicate_enum_name():
+    with pytest.raises(ValueError) as excinfo:
+        m.register_bad_enum()
+    assert str(excinfo.value) == 'SimpleEnum: element "ONE" already exists!'
+
+
+def test_char_underlying_enum():  # Issue #1331/PR #1334:
+    assert type(m.ScopedCharEnum.Positive.__int__()) is int
+    assert int(m.ScopedChar16Enum.Zero) == 0
+    assert hash(m.ScopedChar32Enum.Positive) == 1
+    assert type(m.ScopedCharEnum.Positive.__getstate__()) is int
+    assert m.ScopedWCharEnum(1) == m.ScopedWCharEnum.Positive
+    with pytest.raises(TypeError):
+        # Even if the underlying type is char, only an int can be used to construct the enum:
+        m.ScopedCharEnum("0")
+
+
+def test_bool_underlying_enum():
+    assert type(m.ScopedBoolEnum.TRUE.__int__()) is int
+    assert int(m.ScopedBoolEnum.FALSE) == 0
+    assert hash(m.ScopedBoolEnum.TRUE) == 1
+    assert type(m.ScopedBoolEnum.TRUE.__getstate__()) is int
+    assert m.ScopedBoolEnum(1) == m.ScopedBoolEnum.TRUE
+    # Enum could construct with a bool
+    # (bool is a strict subclass of int, and False will be converted to 0)
+    assert m.ScopedBoolEnum(False) == m.ScopedBoolEnum.FALSE
+
+
+def test_docstring_signatures():
+    for enum_type in [m.ScopedEnum, m.UnscopedEnum]:
+        for attr in enum_type.__dict__.values():
+            # Issue #2623/PR #2637: Add argument names to enum_ methods
+            assert "arg0" not in (attr.__doc__ or "")
+
+
+def test_str_signature():
+    for enum_type in [m.ScopedEnum, m.UnscopedEnum]:
+        assert enum_type.__str__.__doc__.startswith("__str__")

third_party/CityFlow/extern/pybind11/tests/test_eval.cpp

@@ -1,118 +1,118 @@
-/*
-    tests/test_eval.cpp -- Usage of eval() and eval_file()
-
-    Copyright (c) 2016 Klemens D. Morgenstern
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <pybind11/eval.h>
-
-#include "pybind11_tests.h"
-
-#include <utility>
-
-TEST_SUBMODULE(eval_, m) {
-    // test_evals
-
-    auto global = py::dict(py::module_::import("__main__").attr("__dict__"));
-
-    m.def("test_eval_statements", [global]() {
-        auto local = py::dict();
-        local["call_test"] = py::cpp_function([&]() -> int { return 42; });
-
-        // Regular string literal
-        py::exec("message = 'Hello World!'\n"
-                 "x = call_test()",
-                 global,
-                 local);
-
-        // Multi-line raw string literal
-        py::exec(R"(
-            if x == 42:
-                print(message)
-            else:
-                raise RuntimeError
-            )",
-                 global,
-                 local);
-        auto x = local["x"].cast<int>();
-
-        return x == 42;
-    });
-
-    m.def("test_eval", [global]() {
-        auto local = py::dict();
-        local["x"] = py::int_(42);
-        auto x = py::eval("x", global, local);
-        return x.cast<int>() == 42;
-    });
-
-    m.def("test_eval_single_statement", []() {
-        auto local = py::dict();
-        local["call_test"] = py::cpp_function([&]() -> int { return 42; });
-
-        auto result = py::eval<py::eval_single_statement>("x = call_test()", py::dict(), local);
-        auto x = local["x"].cast<int>();
-        return result.is_none() && x == 42;
-    });
-
-    m.def("test_eval_file", [global](py::str filename) {
-        auto local = py::dict();
-        local["y"] = py::int_(43);
-
-        int val_out = 0;
-        local["call_test2"] = py::cpp_function([&](int value) { val_out = value; });
-
-        auto result = py::eval_file(std::move(filename), global, local);
-        return val_out == 43 && result.is_none();
-    });
-
-    m.def("test_eval_failure", []() {
-        try {
-            py::eval("nonsense code ...");
-        } catch (py::error_already_set &) {
-            return true;
-        }
-        return false;
-    });
-
-    m.def("test_eval_file_failure", []() {
-        try {
-            py::eval_file("non-existing file");
-        } catch (std::exception &) {
-            return true;
-        }
-        return false;
-    });
-
-    // test_eval_empty_globals
-    m.def("eval_empty_globals", [](py::object global) {
-        if (global.is_none()) {
-            global = py::dict();
-        }
-        auto int_class = py::eval("isinstance(42, int)", global);
-        return global;
-    });
-
-    // test_eval_closure
-    m.def("test_eval_closure", []() {
-        py::dict global;
-        global["closure_value"] = 42;
-        py::dict local;
-        local["closure_value"] = 0;
-        py::exec(R"(
-            local_value = closure_value
-
-            def func_global():
-                return closure_value
-
-            def func_local():
-                return local_value
-            )",
-                 global,
-                 local);
-        return std::make_pair(global, local);
-    });
-}
+/*
+    tests/test_eval.cpp -- Usage of eval() and eval_file()
+
+    Copyright (c) 2016 Klemens D. Morgenstern
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#include <pybind11/eval.h>
+
+#include "pybind11_tests.h"
+
+#include <utility>
+
+TEST_SUBMODULE(eval_, m) {
+    // test_evals
+
+    auto global = py::dict(py::module_::import("__main__").attr("__dict__"));
+
+    m.def("test_eval_statements", [global]() {
+        auto local = py::dict();
+        local["call_test"] = py::cpp_function([&]() -> int { return 42; });
+
+        // Regular string literal
+        py::exec("message = 'Hello World!'\n"
+                 "x = call_test()",
+                 global,
+                 local);
+
+        // Multi-line raw string literal
+        py::exec(R"(
+            if x == 42:
+                print(message)
+            else:
+                raise RuntimeError
+            )",
+                 global,
+                 local);
+        auto x = local["x"].cast<int>();
+
+        return x == 42;
+    });
+
+    m.def("test_eval", [global]() {
+        auto local = py::dict();
+        local["x"] = py::int_(42);
+        auto x = py::eval("x", global, local);
+        return x.cast<int>() == 42;
+    });
+
+    m.def("test_eval_single_statement", []() {
+        auto local = py::dict();
+        local["call_test"] = py::cpp_function([&]() -> int { return 42; });
+
+        auto result = py::eval<py::eval_single_statement>("x = call_test()", py::dict(), local);
+        auto x = local["x"].cast<int>();
+        return result.is_none() && x == 42;
+    });
+
+    m.def("test_eval_file", [global](py::str filename) {
+        auto local = py::dict();
+        local["y"] = py::int_(43);
+
+        int val_out = 0;
+        local["call_test2"] = py::cpp_function([&](int value) { val_out = value; });
+
+        auto result = py::eval_file(std::move(filename), global, local);
+        return val_out == 43 && result.is_none();
+    });
+
+    m.def("test_eval_failure", []() {
+        try {
+            py::eval("nonsense code ...");
+        } catch (py::error_already_set &) {
+            return true;
+        }
+        return false;
+    });
+
+    m.def("test_eval_file_failure", []() {
+        try {
+            py::eval_file("non-existing file");
+        } catch (std::exception &) {
+            return true;
+        }
+        return false;
+    });
+
+    // test_eval_empty_globals
+    m.def("eval_empty_globals", [](py::object global) {
+        if (global.is_none()) {
+            global = py::dict();
+        }
+        auto int_class = py::eval("isinstance(42, int)", global);
+        return global;
+    });
+
+    // test_eval_closure
+    m.def("test_eval_closure", []() {
+        py::dict global;
+        global["closure_value"] = 42;
+        py::dict local;
+        local["closure_value"] = 0;
+        py::exec(R"(
+            local_value = closure_value
+
+            def func_global():
+                return closure_value
+
+            def func_local():
+                return local_value
+            )",
+                 global,
+                 local);
+        return std::make_pair(global, local);
+    });
+}

third_party/CityFlow/extern/pybind11/tests/test_eval.py

@@ -1,50 +1,50 @@
-import os
-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import eval_ as m
-
-
-def test_evals(capture):
-    with capture:
-        assert m.test_eval_statements()
-    assert capture == "Hello World!"
-
-    assert m.test_eval()
-    assert m.test_eval_single_statement()
-
-    assert m.test_eval_failure()
-
-
-@pytest.mark.xfail("env.PYPY", raises=RuntimeError)
-def test_eval_file():
-    filename = os.path.join(os.path.dirname(__file__), "test_eval_call.py")
-    assert m.test_eval_file(filename)
-
-    assert m.test_eval_file_failure()
-
-
-def test_eval_empty_globals():
-    assert "__builtins__" in m.eval_empty_globals(None)
-
-    g = {}
-    assert "__builtins__" in m.eval_empty_globals(g)
-    assert "__builtins__" in g
-
-
-def test_eval_closure():
-    global_, local = m.test_eval_closure()
-
-    assert global_["closure_value"] == 42
-    assert local["closure_value"] == 0
-
-    assert "local_value" not in global_
-    assert local["local_value"] == 0
-
-    assert "func_global" not in global_
-    assert local["func_global"]() == 42
-
-    assert "func_local" not in global_
-    with pytest.raises(NameError):
-        local["func_local"]()
+import os
+
+import pytest
+
+import env  # noqa: F401
+from pybind11_tests import eval_ as m
+
+
+def test_evals(capture):
+    with capture:
+        assert m.test_eval_statements()
+    assert capture == "Hello World!"
+
+    assert m.test_eval()
+    assert m.test_eval_single_statement()
+
+    assert m.test_eval_failure()
+
+
+@pytest.mark.xfail("env.PYPY", raises=RuntimeError)
+def test_eval_file():
+    filename = os.path.join(os.path.dirname(__file__), "test_eval_call.py")
+    assert m.test_eval_file(filename)
+
+    assert m.test_eval_file_failure()
+
+
+def test_eval_empty_globals():
+    assert "__builtins__" in m.eval_empty_globals(None)
+
+    g = {}
+    assert "__builtins__" in m.eval_empty_globals(g)
+    assert "__builtins__" in g
+
+
+def test_eval_closure():
+    global_, local = m.test_eval_closure()
+
+    assert global_["closure_value"] == 42
+    assert local["closure_value"] == 0
+
+    assert "local_value" not in global_
+    assert local["local_value"] == 0
+
+    assert "func_global" not in global_
+    assert local["func_global"]() == 42
+
+    assert "func_local" not in global_
+    with pytest.raises(NameError):
+        local["func_local"]()

third_party/CityFlow/extern/pybind11/tests/test_eval_call.py

@@ -1,4 +1,4 @@
-# This file is called from 'test_eval.py'
-
-if "call_test2" in locals():
-    call_test2(y)  # noqa: F821 undefined name
+# This file is called from 'test_eval.py'
+
+if "call_test2" in locals():
+    call_test2(y)  # noqa: F821 undefined name

third_party/CityFlow/extern/pybind11/tests/test_exceptions.cpp

@@ -1,388 +1,388 @@
-/*
-    tests/test_custom-exceptions.cpp -- exception translation
-
-    Copyright (c) 2016 Pim Schellart <P.Schellart@princeton.edu>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-#include <pybind11/gil_safe_call_once.h>
-
-#include "test_exceptions.h"
-
-#include "local_bindings.h"
-#include "pybind11_tests.h"
-
-#include <exception>
-#include <stdexcept>
-#include <utility>
-
-// A type that should be raised as an exception in Python
-class MyException : public std::exception {
-public:
-    explicit MyException(const char *m) : message{m} {}
-    const char *what() const noexcept override { return message.c_str(); }
-
-private:
-    std::string message = "";
-};
-
-class MyExceptionUseDeprecatedOperatorCall : public MyException {
-    using MyException::MyException;
-};
-
-// A type that should be translated to a standard Python exception
-class MyException2 : public std::exception {
-public:
-    explicit MyException2(const char *m) : message{m} {}
-    const char *what() const noexcept override { return message.c_str(); }
-
-private:
-    std::string message = "";
-};
-
-// A type that is not derived from std::exception (and is thus unknown)
-class MyException3 {
-public:
-    explicit MyException3(const char *m) : message{m} {}
-    virtual const char *what() const noexcept { return message.c_str(); }
-    // Rule of 5 BEGIN: to preempt compiler warnings.
-    MyException3(const MyException3 &) = default;
-    MyException3(MyException3 &&) = default;
-    MyException3 &operator=(const MyException3 &) = default;
-    MyException3 &operator=(MyException3 &&) = default;
-    virtual ~MyException3() = default;
-    // Rule of 5 END.
-private:
-    std::string message = "";
-};
-
-// A type that should be translated to MyException
-// and delegated to its exception translator
-class MyException4 : public std::exception {
-public:
-    explicit MyException4(const char *m) : message{m} {}
-    const char *what() const noexcept override { return message.c_str(); }
-
-private:
-    std::string message = "";
-};
-
-// Like the above, but declared via the helper function
-class MyException5 : public std::logic_error {
-public:
-    explicit MyException5(const std::string &what) : std::logic_error(what) {}
-};
-
-// Inherits from MyException5
-class MyException5_1 : public MyException5 {
-    using MyException5::MyException5;
-};
-
-// Exception that will be caught via the module local translator.
-class MyException6 : public std::exception {
-public:
-    explicit MyException6(const char *m) : message{m} {}
-    const char *what() const noexcept override { return message.c_str(); }
-
-private:
-    std::string message = "";
-};
-
-struct PythonCallInDestructor {
-    explicit PythonCallInDestructor(const py::dict &d) : d(d) {}
-    ~PythonCallInDestructor() { d["good"] = true; }
-
-    py::dict d;
-};
-
-struct PythonAlreadySetInDestructor {
-    explicit PythonAlreadySetInDestructor(const py::str &s) : s(s) {}
-    ~PythonAlreadySetInDestructor() {
-        py::dict foo;
-        try {
-            // Assign to a py::object to force read access of nonexistent dict entry
-            py::object o = foo["bar"];
-        } catch (py::error_already_set &ex) {
-            ex.discard_as_unraisable(s);
-        }
-    }
-
-    py::str s;
-};
-
-TEST_SUBMODULE(exceptions, m) {
-    m.def("throw_std_exception",
-          []() { throw std::runtime_error("This exception was intentionally thrown."); });
-
-    // PLEASE KEEP IN SYNC with docs/advanced/exceptions.rst
-    PYBIND11_CONSTINIT static py::gil_safe_call_once_and_store<py::object> ex_storage;
-    ex_storage.call_once_and_store_result(
-        [&]() { return py::exception<MyException>(m, "MyException"); });
-    py::register_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) {
-                std::rethrow_exception(p);
-            }
-        } catch (const MyException &e) {
-            // Set MyException as the active python error
-            py::set_error(ex_storage.get_stored(), e.what());
-        }
-    });
-
-    // Same as above, but using the deprecated `py::exception<>::operator()`
-    // We want to be sure it still works, until it's removed.
-    static const auto *const exd = new py::exception<MyExceptionUseDeprecatedOperatorCall>(
-        m, "MyExceptionUseDeprecatedOperatorCall");
-    py::register_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) {
-                std::rethrow_exception(p);
-            }
-        } catch (const MyExceptionUseDeprecatedOperatorCall &e) {
-#if defined(__INTEL_COMPILER) || defined(__NVCOMPILER)
-            // It is not worth the trouble dealing with warning suppressions for these compilers.
-            // Falling back to the recommended approach to keep the test code simple.
-            py::set_error(*exd, e.what());
-#else
-            PYBIND11_WARNING_PUSH
-            PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated-declarations")
-            PYBIND11_WARNING_DISABLE_GCC("-Wdeprecated-declarations")
-            PYBIND11_WARNING_DISABLE_MSVC(4996)
-            (*exd)(e.what());
-            PYBIND11_WARNING_POP
-#endif
-        }
-    });
-
-    // register new translator for MyException2
-    // no need to store anything here because this type will
-    // never by visible from Python
-    py::register_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) {
-                std::rethrow_exception(p);
-            }
-        } catch (const MyException2 &e) {
-            // Translate this exception to a standard RuntimeError
-            py::set_error(PyExc_RuntimeError, e.what());
-        }
-    });
-
-    // register new translator for MyException4
-    // which will catch it and delegate to the previously registered
-    // translator for MyException by throwing a new exception
-    py::register_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) {
-                std::rethrow_exception(p);
-            }
-        } catch (const MyException4 &e) {
-            throw MyException(e.what());
-        }
-    });
-
-    // A simple exception translation:
-    auto ex5 = py::register_exception<MyException5>(m, "MyException5");
-    // A slightly more complicated one that declares MyException5_1 as a subclass of MyException5
-    py::register_exception<MyException5_1>(m, "MyException5_1", ex5.ptr());
-
-    // py::register_local_exception<LocalSimpleException>(m, "LocalSimpleException")
-
-    py::register_local_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) {
-                std::rethrow_exception(p);
-            }
-        } catch (const MyException6 &e) {
-            py::set_error(PyExc_RuntimeError, e.what());
-        }
-    });
-
-    m.def("throws1",
-          []() { throw MyException("this error should go to py::exception<MyException>"); });
-    m.def("throws1d", []() {
-        throw MyExceptionUseDeprecatedOperatorCall(
-            "this error should go to py::exception<MyExceptionUseDeprecatedOperatorCall>");
-    });
-    m.def("throws2",
-          []() { throw MyException2("this error should go to a standard Python exception"); });
-    m.def("throws3", []() { throw MyException3("this error cannot be translated"); });
-    m.def("throws4", []() { throw MyException4("this error is rethrown"); });
-    m.def("throws5",
-          []() { throw MyException5("this is a helper-defined translated exception"); });
-    m.def("throws5_1", []() { throw MyException5_1("MyException5 subclass"); });
-    m.def("throws6", []() { throw MyException6("MyException6 only handled in this module"); });
-    m.def("throws_logic_error", []() {
-        throw std::logic_error("this error should fall through to the standard handler");
-    });
-    m.def("throws_overflow_error", []() { throw std::overflow_error(""); });
-    m.def("throws_local_error", []() { throw LocalException("never caught"); });
-    m.def("throws_local_simple_error", []() { throw LocalSimpleException("this mod"); });
-    m.def("exception_matches", []() {
-        py::dict foo;
-        try {
-            // Assign to a py::object to force read access of nonexistent dict entry
-            py::object o = foo["bar"];
-        } catch (py::error_already_set &ex) {
-            if (!ex.matches(PyExc_KeyError)) {
-                throw;
-            }
-            return true;
-        }
-        return false;
-    });
-    m.def("exception_matches_base", []() {
-        py::dict foo;
-        try {
-            // Assign to a py::object to force read access of nonexistent dict entry
-            py::object o = foo["bar"];
-        } catch (py::error_already_set &ex) {
-            if (!ex.matches(PyExc_Exception)) {
-                throw;
-            }
-            return true;
-        }
-        return false;
-    });
-    m.def("modulenotfound_exception_matches_base", []() {
-        try {
-            // On Python >= 3.6, this raises a ModuleNotFoundError, a subclass of ImportError
-            py::module_::import("nonexistent");
-        } catch (py::error_already_set &ex) {
-            if (!ex.matches(PyExc_ImportError)) {
-                throw;
-            }
-            return true;
-        }
-        return false;
-    });
-
-    m.def("throw_already_set", [](bool err) {
-        if (err) {
-            py::set_error(PyExc_ValueError, "foo");
-        }
-        try {
-            throw py::error_already_set();
-        } catch (const std::runtime_error &e) {
-            if ((err && e.what() != std::string("ValueError: foo"))
-                || (!err
-                    && e.what()
-                           != std::string("Internal error: pybind11::error_already_set called "
-                                          "while Python error indicator not set."))) {
-                PyErr_Clear();
-                throw std::runtime_error("error message mismatch");
-            }
-        }
-        PyErr_Clear();
-        if (err) {
-            py::set_error(PyExc_ValueError, "foo");
-        }
-        throw py::error_already_set();
-    });
-
-    m.def("python_call_in_destructor", [](const py::dict &d) {
-        bool retval = false;
-        try {
-            PythonCallInDestructor set_dict_in_destructor(d);
-            py::set_error(PyExc_ValueError, "foo");
-            throw py::error_already_set();
-        } catch (const py::error_already_set &) {
-            retval = true;
-        }
-        return retval;
-    });
-
-    m.def("python_alreadyset_in_destructor", [](const py::str &s) {
-        PythonAlreadySetInDestructor alreadyset_in_destructor(s);
-        return true;
-    });
-
-    // test_nested_throws
-    m.def("try_catch",
-          [m](const py::object &exc_type, const py::function &f, const py::args &args) {
-              try {
-                  f(*args);
-              } catch (py::error_already_set &ex) {
-                  if (ex.matches(exc_type)) {
-                      py::print(ex.what());
-                  } else {
-                      // Simply `throw;` also works and is better, but using `throw ex;`
-                      // here to cover that situation (as observed in the wild).
-                      throw ex; // Invokes the copy ctor.
-                  }
-              }
-          });
-
-    // Test repr that cannot be displayed
-    m.def("simple_bool_passthrough", [](bool x) { return x; });
-
-    m.def("throw_should_be_translated_to_key_error", []() { throw shared_exception(); });
-
-    m.def("raise_from", []() {
-        py::set_error(PyExc_ValueError, "inner");
-        py::raise_from(PyExc_ValueError, "outer");
-        throw py::error_already_set();
-    });
-
-    m.def("raise_from_already_set", []() {
-        try {
-            py::set_error(PyExc_ValueError, "inner");
-            throw py::error_already_set();
-        } catch (py::error_already_set &e) {
-            py::raise_from(e, PyExc_ValueError, "outer");
-            throw py::error_already_set();
-        }
-    });
-
-    m.def("throw_nested_exception", []() {
-        try {
-            throw std::runtime_error("Inner Exception");
-        } catch (const std::runtime_error &) {
-            std::throw_with_nested(std::runtime_error("Outer Exception"));
-        }
-    });
-
-    m.def("error_already_set_what", [](const py::object &exc_type, const py::object &exc_value) {
-        py::set_error(exc_type, exc_value);
-        std::string what = py::error_already_set().what();
-        bool py_err_set_after_what = (PyErr_Occurred() != nullptr);
-        PyErr_Clear();
-        return py::make_tuple(std::move(what), py_err_set_after_what);
-    });
-
-    m.def("test_cross_module_interleaved_error_already_set", []() {
-        auto cm = py::module_::import("cross_module_interleaved_error_already_set");
-        auto interleaved_error_already_set
-            = reinterpret_cast<void (*)()>(PyLong_AsVoidPtr(cm.attr("funcaddr").ptr()));
-        interleaved_error_already_set();
-    });
-
-    m.def("test_error_already_set_double_restore", [](bool dry_run) {
-        py::set_error(PyExc_ValueError, "Random error.");
-        py::error_already_set e;
-        e.restore();
-        PyErr_Clear();
-        if (!dry_run) {
-            e.restore();
-        }
-    });
-
-    // https://github.com/pybind/pybind11/issues/4075
-    m.def("test_pypy_oserror_normalization", []() {
-        try {
-            py::module_::import("io").attr("open")("this_filename_must_not_exist", "r");
-        } catch (const py::error_already_set &e) {
-            return py::str(e.what()); // str must be built before e goes out of scope.
-        }
-        return py::str("UNEXPECTED");
-    });
-
-    m.def("test_fn_cast_int", [](const py::function &fn) {
-        // function returns None instead of int, should give a useful error message
-        fn().cast<int>();
-    });
-
-    // m.def("pass_exception_void", [](const py::exception<void>&) {}); // Does not compile.
-    m.def("return_exception_void", []() { return py::exception<void>(); });
-}
+/*
+    tests/test_custom-exceptions.cpp -- exception translation
+
+    Copyright (c) 2016 Pim Schellart <P.Schellart@princeton.edu>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+#include <pybind11/gil_safe_call_once.h>
+
+#include "test_exceptions.h"
+
+#include "local_bindings.h"
+#include "pybind11_tests.h"
+
+#include <exception>
+#include <stdexcept>
+#include <utility>
+
+// A type that should be raised as an exception in Python
+class MyException : public std::exception {
+public:
+    explicit MyException(const char *m) : message{m} {}
+    const char *what() const noexcept override { return message.c_str(); }
+
+private:
+    std::string message = "";
+};
+
+class MyExceptionUseDeprecatedOperatorCall : public MyException {
+    using MyException::MyException;
+};
+
+// A type that should be translated to a standard Python exception
+class MyException2 : public std::exception {
+public:
+    explicit MyException2(const char *m) : message{m} {}
+    const char *what() const noexcept override { return message.c_str(); }
+
+private:
+    std::string message = "";
+};
+
+// A type that is not derived from std::exception (and is thus unknown)
+class MyException3 {
+public:
+    explicit MyException3(const char *m) : message{m} {}
+    virtual const char *what() const noexcept { return message.c_str(); }
+    // Rule of 5 BEGIN: to preempt compiler warnings.
+    MyException3(const MyException3 &) = default;
+    MyException3(MyException3 &&) = default;
+    MyException3 &operator=(const MyException3 &) = default;
+    MyException3 &operator=(MyException3 &&) = default;
+    virtual ~MyException3() = default;
+    // Rule of 5 END.
+private:
+    std::string message = "";
+};
+
+// A type that should be translated to MyException
+// and delegated to its exception translator
+class MyException4 : public std::exception {
+public:
+    explicit MyException4(const char *m) : message{m} {}
+    const char *what() const noexcept override { return message.c_str(); }
+
+private:
+    std::string message = "";
+};
+
+// Like the above, but declared via the helper function
+class MyException5 : public std::logic_error {
+public:
+    explicit MyException5(const std::string &what) : std::logic_error(what) {}
+};
+
+// Inherits from MyException5
+class MyException5_1 : public MyException5 {
+    using MyException5::MyException5;
+};
+
+// Exception that will be caught via the module local translator.
+class MyException6 : public std::exception {
+public:
+    explicit MyException6(const char *m) : message{m} {}
+    const char *what() const noexcept override { return message.c_str(); }
+
+private:
+    std::string message = "";
+};
+
+struct PythonCallInDestructor {
+    explicit PythonCallInDestructor(const py::dict &d) : d(d) {}
+    ~PythonCallInDestructor() { d["good"] = true; }
+
+    py::dict d;
+};
+
+struct PythonAlreadySetInDestructor {
+    explicit PythonAlreadySetInDestructor(const py::str &s) : s(s) {}
+    ~PythonAlreadySetInDestructor() {
+        py::dict foo;
+        try {
+            // Assign to a py::object to force read access of nonexistent dict entry
+            py::object o = foo["bar"];
+        } catch (py::error_already_set &ex) {
+            ex.discard_as_unraisable(s);
+        }
+    }
+
+    py::str s;
+};
+
+TEST_SUBMODULE(exceptions, m) {
+    m.def("throw_std_exception",
+          []() { throw std::runtime_error("This exception was intentionally thrown."); });
+
+    // PLEASE KEEP IN SYNC with docs/advanced/exceptions.rst
+    PYBIND11_CONSTINIT static py::gil_safe_call_once_and_store<py::object> ex_storage;
+    ex_storage.call_once_and_store_result(
+        [&]() { return py::exception<MyException>(m, "MyException"); });
+    py::register_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const MyException &e) {
+            // Set MyException as the active python error
+            py::set_error(ex_storage.get_stored(), e.what());
+        }
+    });
+
+    // Same as above, but using the deprecated `py::exception<>::operator()`
+    // We want to be sure it still works, until it's removed.
+    static const auto *const exd = new py::exception<MyExceptionUseDeprecatedOperatorCall>(
+        m, "MyExceptionUseDeprecatedOperatorCall");
+    py::register_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const MyExceptionUseDeprecatedOperatorCall &e) {
+#if defined(__INTEL_COMPILER) || defined(__NVCOMPILER)
+            // It is not worth the trouble dealing with warning suppressions for these compilers.
+            // Falling back to the recommended approach to keep the test code simple.
+            py::set_error(*exd, e.what());
+#else
+            PYBIND11_WARNING_PUSH
+            PYBIND11_WARNING_DISABLE_CLANG("-Wdeprecated-declarations")
+            PYBIND11_WARNING_DISABLE_GCC("-Wdeprecated-declarations")
+            PYBIND11_WARNING_DISABLE_MSVC(4996)
+            (*exd)(e.what());
+            PYBIND11_WARNING_POP
+#endif
+        }
+    });
+
+    // register new translator for MyException2
+    // no need to store anything here because this type will
+    // never by visible from Python
+    py::register_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const MyException2 &e) {
+            // Translate this exception to a standard RuntimeError
+            py::set_error(PyExc_RuntimeError, e.what());
+        }
+    });
+
+    // register new translator for MyException4
+    // which will catch it and delegate to the previously registered
+    // translator for MyException by throwing a new exception
+    py::register_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const MyException4 &e) {
+            throw MyException(e.what());
+        }
+    });
+
+    // A simple exception translation:
+    auto ex5 = py::register_exception<MyException5>(m, "MyException5");
+    // A slightly more complicated one that declares MyException5_1 as a subclass of MyException5
+    py::register_exception<MyException5_1>(m, "MyException5_1", ex5.ptr());
+
+    // py::register_local_exception<LocalSimpleException>(m, "LocalSimpleException")
+
+    py::register_local_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const MyException6 &e) {
+            py::set_error(PyExc_RuntimeError, e.what());
+        }
+    });
+
+    m.def("throws1",
+          []() { throw MyException("this error should go to py::exception<MyException>"); });
+    m.def("throws1d", []() {
+        throw MyExceptionUseDeprecatedOperatorCall(
+            "this error should go to py::exception<MyExceptionUseDeprecatedOperatorCall>");
+    });
+    m.def("throws2",
+          []() { throw MyException2("this error should go to a standard Python exception"); });
+    m.def("throws3", []() { throw MyException3("this error cannot be translated"); });
+    m.def("throws4", []() { throw MyException4("this error is rethrown"); });
+    m.def("throws5",
+          []() { throw MyException5("this is a helper-defined translated exception"); });
+    m.def("throws5_1", []() { throw MyException5_1("MyException5 subclass"); });
+    m.def("throws6", []() { throw MyException6("MyException6 only handled in this module"); });
+    m.def("throws_logic_error", []() {
+        throw std::logic_error("this error should fall through to the standard handler");
+    });
+    m.def("throws_overflow_error", []() { throw std::overflow_error(""); });
+    m.def("throws_local_error", []() { throw LocalException("never caught"); });
+    m.def("throws_local_simple_error", []() { throw LocalSimpleException("this mod"); });
+    m.def("exception_matches", []() {
+        py::dict foo;
+        try {
+            // Assign to a py::object to force read access of nonexistent dict entry
+            py::object o = foo["bar"];
+        } catch (py::error_already_set &ex) {
+            if (!ex.matches(PyExc_KeyError)) {
+                throw;
+            }
+            return true;
+        }
+        return false;
+    });
+    m.def("exception_matches_base", []() {
+        py::dict foo;
+        try {
+            // Assign to a py::object to force read access of nonexistent dict entry
+            py::object o = foo["bar"];
+        } catch (py::error_already_set &ex) {
+            if (!ex.matches(PyExc_Exception)) {
+                throw;
+            }
+            return true;
+        }
+        return false;
+    });
+    m.def("modulenotfound_exception_matches_base", []() {
+        try {
+            // On Python >= 3.6, this raises a ModuleNotFoundError, a subclass of ImportError
+            py::module_::import("nonexistent");
+        } catch (py::error_already_set &ex) {
+            if (!ex.matches(PyExc_ImportError)) {
+                throw;
+            }
+            return true;
+        }
+        return false;
+    });
+
+    m.def("throw_already_set", [](bool err) {
+        if (err) {
+            py::set_error(PyExc_ValueError, "foo");
+        }
+        try {
+            throw py::error_already_set();
+        } catch (const std::runtime_error &e) {
+            if ((err && e.what() != std::string("ValueError: foo"))
+                || (!err
+                    && e.what()
+                           != std::string("Internal error: pybind11::error_already_set called "
+                                          "while Python error indicator not set."))) {
+                PyErr_Clear();
+                throw std::runtime_error("error message mismatch");
+            }
+        }
+        PyErr_Clear();
+        if (err) {
+            py::set_error(PyExc_ValueError, "foo");
+        }
+        throw py::error_already_set();
+    });
+
+    m.def("python_call_in_destructor", [](const py::dict &d) {
+        bool retval = false;
+        try {
+            PythonCallInDestructor set_dict_in_destructor(d);
+            py::set_error(PyExc_ValueError, "foo");
+            throw py::error_already_set();
+        } catch (const py::error_already_set &) {
+            retval = true;
+        }
+        return retval;
+    });
+
+    m.def("python_alreadyset_in_destructor", [](const py::str &s) {
+        PythonAlreadySetInDestructor alreadyset_in_destructor(s);
+        return true;
+    });
+
+    // test_nested_throws
+    m.def("try_catch",
+          [m](const py::object &exc_type, const py::function &f, const py::args &args) {
+              try {
+                  f(*args);
+              } catch (py::error_already_set &ex) {
+                  if (ex.matches(exc_type)) {
+                      py::print(ex.what());
+                  } else {
+                      // Simply `throw;` also works and is better, but using `throw ex;`
+                      // here to cover that situation (as observed in the wild).
+                      throw ex; // Invokes the copy ctor.
+                  }
+              }
+          });
+
+    // Test repr that cannot be displayed
+    m.def("simple_bool_passthrough", [](bool x) { return x; });
+
+    m.def("throw_should_be_translated_to_key_error", []() { throw shared_exception(); });
+
+    m.def("raise_from", []() {
+        py::set_error(PyExc_ValueError, "inner");
+        py::raise_from(PyExc_ValueError, "outer");
+        throw py::error_already_set();
+    });
+
+    m.def("raise_from_already_set", []() {
+        try {
+            py::set_error(PyExc_ValueError, "inner");
+            throw py::error_already_set();
+        } catch (py::error_already_set &e) {
+            py::raise_from(e, PyExc_ValueError, "outer");
+            throw py::error_already_set();
+        }
+    });
+
+    m.def("throw_nested_exception", []() {
+        try {
+            throw std::runtime_error("Inner Exception");
+        } catch (const std::runtime_error &) {
+            std::throw_with_nested(std::runtime_error("Outer Exception"));
+        }
+    });
+
+    m.def("error_already_set_what", [](const py::object &exc_type, const py::object &exc_value) {
+        py::set_error(exc_type, exc_value);
+        std::string what = py::error_already_set().what();
+        bool py_err_set_after_what = (PyErr_Occurred() != nullptr);
+        PyErr_Clear();
+        return py::make_tuple(std::move(what), py_err_set_after_what);
+    });
+
+    m.def("test_cross_module_interleaved_error_already_set", []() {
+        auto cm = py::module_::import("cross_module_interleaved_error_already_set");
+        auto interleaved_error_already_set
+            = reinterpret_cast<void (*)()>(PyLong_AsVoidPtr(cm.attr("funcaddr").ptr()));
+        interleaved_error_already_set();
+    });
+
+    m.def("test_error_already_set_double_restore", [](bool dry_run) {
+        py::set_error(PyExc_ValueError, "Random error.");
+        py::error_already_set e;
+        e.restore();
+        PyErr_Clear();
+        if (!dry_run) {
+            e.restore();
+        }
+    });
+
+    // https://github.com/pybind/pybind11/issues/4075
+    m.def("test_pypy_oserror_normalization", []() {
+        try {
+            py::module_::import("io").attr("open")("this_filename_must_not_exist", "r");
+        } catch (const py::error_already_set &e) {
+            return py::str(e.what()); // str must be built before e goes out of scope.
+        }
+        return py::str("UNEXPECTED");
+    });
+
+    m.def("test_fn_cast_int", [](const py::function &fn) {
+        // function returns None instead of int, should give a useful error message
+        fn().cast<int>();
+    });
+
+    // m.def("pass_exception_void", [](const py::exception<void>&) {}); // Does not compile.
+    m.def("return_exception_void", []() { return py::exception<void>(); });
+}

third_party/CityFlow/extern/pybind11/tests/test_exceptions.h

@@ -1,13 +1,13 @@
-#pragma once
-#include "pybind11_tests.h"
-
-#include <stdexcept>
-
-// shared exceptions for cross_module_tests
-
-class PYBIND11_EXPORT_EXCEPTION shared_exception : public pybind11::builtin_exception {
-public:
-    using builtin_exception::builtin_exception;
-    explicit shared_exception() : shared_exception("") {}
-    void set_error() const override { py::set_error(PyExc_RuntimeError, what()); }
-};
+#pragma once
+#include "pybind11_tests.h"
+
+#include <stdexcept>
+
+// shared exceptions for cross_module_tests
+
+class PYBIND11_EXPORT_EXCEPTION shared_exception : public pybind11::builtin_exception {
+public:
+    using builtin_exception::builtin_exception;
+    explicit shared_exception() : shared_exception("") {}
+    void set_error() const override { py::set_error(PyExc_RuntimeError, what()); }
+};

third_party/CityFlow/extern/pybind11/tests/test_exceptions.py

@@ -1,432 +1,432 @@
-import sys
-
-import pytest
-
-import env
-import pybind11_cross_module_tests as cm
-import pybind11_tests
-from pybind11_tests import exceptions as m
-
-
-def test_std_exception(msg):
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throw_std_exception()
-    assert msg(excinfo.value) == "This exception was intentionally thrown."
-
-
-def test_error_already_set(msg):
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throw_already_set(False)
-    assert (
-        msg(excinfo.value)
-        == "Internal error: pybind11::error_already_set called while Python error indicator not set."
-    )
-
-    with pytest.raises(ValueError) as excinfo:
-        m.throw_already_set(True)
-    assert msg(excinfo.value) == "foo"
-
-
-def test_raise_from(msg):
-    with pytest.raises(ValueError) as excinfo:
-        m.raise_from()
-    assert msg(excinfo.value) == "outer"
-    assert msg(excinfo.value.__cause__) == "inner"
-
-
-def test_raise_from_already_set(msg):
-    with pytest.raises(ValueError) as excinfo:
-        m.raise_from_already_set()
-    assert msg(excinfo.value) == "outer"
-    assert msg(excinfo.value.__cause__) == "inner"
-
-
-def test_cross_module_exceptions(msg):
-    with pytest.raises(RuntimeError) as excinfo:
-        cm.raise_runtime_error()
-    assert str(excinfo.value) == "My runtime error"
-
-    with pytest.raises(ValueError) as excinfo:
-        cm.raise_value_error()
-    assert str(excinfo.value) == "My value error"
-
-    with pytest.raises(ValueError) as excinfo:
-        cm.throw_pybind_value_error()
-    assert str(excinfo.value) == "pybind11 value error"
-
-    with pytest.raises(TypeError) as excinfo:
-        cm.throw_pybind_type_error()
-    assert str(excinfo.value) == "pybind11 type error"
-
-    with pytest.raises(StopIteration) as excinfo:
-        cm.throw_stop_iteration()
-
-    with pytest.raises(cm.LocalSimpleException) as excinfo:
-        cm.throw_local_simple_error()
-    assert msg(excinfo.value) == "external mod"
-
-    with pytest.raises(KeyError) as excinfo:
-        cm.throw_local_error()
-    # KeyError is a repr of the key, so it has an extra set of quotes
-    assert str(excinfo.value) == "'just local'"
-
-
-# TODO: FIXME
-@pytest.mark.xfail(
-    "env.MACOS and (env.PYPY or pybind11_tests.compiler_info.startswith('Homebrew Clang'))",
-    raises=RuntimeError,
-    reason="See Issue #2847, PR #2999, PR #4324",
-)
-def test_cross_module_exception_translator():
-    with pytest.raises(KeyError):
-        # translator registered in cross_module_tests
-        m.throw_should_be_translated_to_key_error()
-
-
-def test_python_call_in_catch():
-    d = {}
-    assert m.python_call_in_destructor(d) is True
-    assert d["good"] is True
-
-
-def ignore_pytest_unraisable_warning(f):
-    unraisable = "PytestUnraisableExceptionWarning"
-    if hasattr(pytest, unraisable):  # Python >= 3.8 and pytest >= 6
-        dec = pytest.mark.filterwarnings(f"ignore::pytest.{unraisable}")
-        return dec(f)
-    return f
-
-
-# TODO: find out why this fails on PyPy, https://foss.heptapod.net/pypy/pypy/-/issues/3583
-@pytest.mark.xfail(env.PYPY, reason="Failure on PyPy 3.8 (7.3.7)", strict=False)
-@ignore_pytest_unraisable_warning
-def test_python_alreadyset_in_destructor(monkeypatch, capsys):
-    hooked = False
-    triggered = False
-
-    if hasattr(sys, "unraisablehook"):  # Python 3.8+
-        hooked = True
-        # Don't take `sys.unraisablehook`, as that's overwritten by pytest
-        default_hook = sys.__unraisablehook__
-
-        def hook(unraisable_hook_args):
-            exc_type, exc_value, exc_tb, err_msg, obj = unraisable_hook_args
-            if obj == "already_set demo":
-                nonlocal triggered
-                triggered = True
-            default_hook(unraisable_hook_args)
-            return
-
-        # Use monkeypatch so pytest can apply and remove the patch as appropriate
-        monkeypatch.setattr(sys, "unraisablehook", hook)
-
-    assert m.python_alreadyset_in_destructor("already_set demo") is True
-    if hooked:
-        assert triggered is True
-
-    _, captured_stderr = capsys.readouterr()
-    assert captured_stderr.startswith("Exception ignored in: 'already_set demo'")
-    assert captured_stderr.rstrip().endswith("KeyError: 'bar'")
-
-
-def test_exception_matches():
-    assert m.exception_matches()
-    assert m.exception_matches_base()
-    assert m.modulenotfound_exception_matches_base()
-
-
-def test_custom(msg):
-    # Can we catch a MyException?
-    with pytest.raises(m.MyException) as excinfo:
-        m.throws1()
-    assert msg(excinfo.value) == "this error should go to py::exception<MyException>"
-
-    # Can we catch a MyExceptionUseDeprecatedOperatorCall?
-    with pytest.raises(m.MyExceptionUseDeprecatedOperatorCall) as excinfo:
-        m.throws1d()
-    assert (
-        msg(excinfo.value)
-        == "this error should go to py::exception<MyExceptionUseDeprecatedOperatorCall>"
-    )
-
-    # Can we translate to standard Python exceptions?
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws2()
-    assert msg(excinfo.value) == "this error should go to a standard Python exception"
-
-    # Can we handle unknown exceptions?
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws3()
-    assert msg(excinfo.value) == "Caught an unknown exception!"
-
-    # Can we delegate to another handler by rethrowing?
-    with pytest.raises(m.MyException) as excinfo:
-        m.throws4()
-    assert msg(excinfo.value) == "this error is rethrown"
-
-    # Can we fall-through to the default handler?
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws_logic_error()
-    assert (
-        msg(excinfo.value) == "this error should fall through to the standard handler"
-    )
-
-    # OverFlow error translation.
-    with pytest.raises(OverflowError) as excinfo:
-        m.throws_overflow_error()
-
-    # Can we handle a helper-declared exception?
-    with pytest.raises(m.MyException5) as excinfo:
-        m.throws5()
-    assert msg(excinfo.value) == "this is a helper-defined translated exception"
-
-    # Exception subclassing:
-    with pytest.raises(m.MyException5) as excinfo:
-        m.throws5_1()
-    assert msg(excinfo.value) == "MyException5 subclass"
-    assert isinstance(excinfo.value, m.MyException5_1)
-
-    with pytest.raises(m.MyException5_1) as excinfo:
-        m.throws5_1()
-    assert msg(excinfo.value) == "MyException5 subclass"
-
-    with pytest.raises(m.MyException5) as excinfo:  # noqa: PT012
-        try:
-            m.throws5()
-        except m.MyException5_1 as err:
-            raise RuntimeError("Exception error: caught child from parent") from err
-    assert msg(excinfo.value) == "this is a helper-defined translated exception"
-
-
-def test_nested_throws(capture):
-    """Tests nested (e.g. C++ -> Python -> C++) exception handling"""
-
-    def throw_myex():
-        raise m.MyException("nested error")
-
-    def throw_myex5():
-        raise m.MyException5("nested error 5")
-
-    # In the comments below, the exception is caught in the first step, thrown in the last step
-
-    # C++ -> Python
-    with capture:
-        m.try_catch(m.MyException5, throw_myex5)
-    assert str(capture).startswith("MyException5: nested error 5")
-
-    # Python -> C++ -> Python
-    with pytest.raises(m.MyException) as excinfo:
-        m.try_catch(m.MyException5, throw_myex)
-    assert str(excinfo.value) == "nested error"
-
-    def pycatch(exctype, f, *args):  # noqa: ARG001
-        try:
-            f(*args)
-        except m.MyException as e:
-            print(e)
-
-    # C++ -> Python -> C++ -> Python
-    with capture:
-        m.try_catch(
-            m.MyException5,
-            pycatch,
-            m.MyException,
-            m.try_catch,
-            m.MyException,
-            throw_myex5,
-        )
-    assert str(capture).startswith("MyException5: nested error 5")
-
-    # C++ -> Python -> C++
-    with capture:
-        m.try_catch(m.MyException, pycatch, m.MyException5, m.throws4)
-    assert capture == "this error is rethrown"
-
-    # Python -> C++ -> Python -> C++
-    with pytest.raises(m.MyException5) as excinfo:
-        m.try_catch(m.MyException, pycatch, m.MyException, m.throws5)
-    assert str(excinfo.value) == "this is a helper-defined translated exception"
-
-
-# TODO: Investigate this crash, see pybind/pybind11#5062 for background
-@pytest.mark.skipif(
-    sys.platform.startswith("win32") and "Clang" in pybind11_tests.compiler_info,
-    reason="Started segfaulting February 2024",
-)
-def test_throw_nested_exception():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throw_nested_exception()
-    assert str(excinfo.value) == "Outer Exception"
-    assert str(excinfo.value.__cause__) == "Inner Exception"
-
-
-# This can often happen if you wrap a pybind11 class in a Python wrapper
-def test_invalid_repr():
-    class MyRepr:
-        def __repr__(self):
-            raise AttributeError("Example error")
-
-    with pytest.raises(TypeError):
-        m.simple_bool_passthrough(MyRepr())
-
-
-def test_local_translator(msg):
-    """Tests that a local translator works and that the local translator from
-    the cross module is not applied"""
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws6()
-    assert msg(excinfo.value) == "MyException6 only handled in this module"
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws_local_error()
-    assert not isinstance(excinfo.value, KeyError)
-    assert msg(excinfo.value) == "never caught"
-
-    with pytest.raises(Exception) as excinfo:
-        m.throws_local_simple_error()
-    assert not isinstance(excinfo.value, cm.LocalSimpleException)
-    assert msg(excinfo.value) == "this mod"
-
-
-def test_error_already_set_message_with_unicode_surrogate():  # Issue #4288
-    assert m.error_already_set_what(RuntimeError, "\ud927") == (
-        "RuntimeError: \\ud927",
-        False,
-    )
-
-
-def test_error_already_set_message_with_malformed_utf8():
-    assert m.error_already_set_what(RuntimeError, b"\x80") == (
-        "RuntimeError: b'\\x80'",
-        False,
-    )
-
-
-class FlakyException(Exception):
-    def __init__(self, failure_point):
-        if failure_point == "failure_point_init":
-            raise ValueError("triggered_failure_point_init")
-        self.failure_point = failure_point
-
-    def __str__(self):
-        if self.failure_point == "failure_point_str":
-            raise ValueError("triggered_failure_point_str")
-        return "FlakyException.__str__"
-
-
-@pytest.mark.parametrize(
-    ("exc_type", "exc_value", "expected_what"),
-    [
-        (ValueError, "plain_str", "ValueError: plain_str"),
-        (ValueError, ("tuple_elem",), "ValueError: tuple_elem"),
-        (FlakyException, ("happy",), "FlakyException: FlakyException.__str__"),
-    ],
-)
-def test_error_already_set_what_with_happy_exceptions(
-    exc_type, exc_value, expected_what
-):
-    what, py_err_set_after_what = m.error_already_set_what(exc_type, exc_value)
-    assert not py_err_set_after_what
-    assert what == expected_what
-
-
-def _test_flaky_exception_failure_point_init_before_py_3_12():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.error_already_set_what(FlakyException, ("failure_point_init",))
-    lines = str(excinfo.value).splitlines()
-    # PyErr_NormalizeException replaces the original FlakyException with ValueError:
-    assert lines[:3] == [
-        "pybind11::error_already_set: MISMATCH of original and normalized active exception types:"
-        " ORIGINAL FlakyException REPLACED BY ValueError: triggered_failure_point_init",
-        "",
-        "At:",
-    ]
-    # Checking the first two lines of the traceback as formatted in error_string():
-    assert "test_exceptions.py(" in lines[3]
-    assert lines[3].endswith("): __init__")
-    assert lines[4].endswith(
-        "): _test_flaky_exception_failure_point_init_before_py_3_12"
-    )
-
-
-def _test_flaky_exception_failure_point_init_py_3_12():
-    # Behavior change in Python 3.12: https://github.com/python/cpython/issues/102594
-    what, py_err_set_after_what = m.error_already_set_what(
-        FlakyException, ("failure_point_init",)
-    )
-    assert not py_err_set_after_what
-    lines = what.splitlines()
-    assert lines[0].endswith("ValueError[WITH __notes__]: triggered_failure_point_init")
-    assert lines[1] == "__notes__ (len=1):"
-    assert "Normalization failed:" in lines[2]
-    assert "FlakyException" in lines[2]
-
-
-@pytest.mark.skipif(
-    "env.PYPY and sys.version_info[:2] < (3, 12)",
-    reason="PyErr_NormalizeException Segmentation fault",
-)
-def test_flaky_exception_failure_point_init():
-    if sys.version_info[:2] < (3, 12):
-        _test_flaky_exception_failure_point_init_before_py_3_12()
-    else:
-        _test_flaky_exception_failure_point_init_py_3_12()
-
-
-def test_flaky_exception_failure_point_str():
-    what, py_err_set_after_what = m.error_already_set_what(
-        FlakyException, ("failure_point_str",)
-    )
-    assert not py_err_set_after_what
-    lines = what.splitlines()
-    n = 3 if env.PYPY and len(lines) == 3 else 5
-    assert (
-        lines[:n]
-        == [
-            "FlakyException: <MESSAGE UNAVAILABLE DUE TO ANOTHER EXCEPTION>",
-            "",
-            "MESSAGE UNAVAILABLE DUE TO EXCEPTION: ValueError: triggered_failure_point_str",
-            "",
-            "At:",
-        ][:n]
-    )
-
-
-def test_cross_module_interleaved_error_already_set():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.test_cross_module_interleaved_error_already_set()
-    assert str(excinfo.value) in (
-        "2nd error.",  # Almost all platforms.
-        "RuntimeError: 2nd error.",  # Some PyPy builds (seen under macOS).
-    )
-
-
-def test_error_already_set_double_restore():
-    m.test_error_already_set_double_restore(True)  # dry_run
-    with pytest.raises(RuntimeError) as excinfo:
-        m.test_error_already_set_double_restore(False)
-    assert str(excinfo.value) == (
-        "Internal error: pybind11::detail::error_fetch_and_normalize::restore()"
-        " called a second time. ORIGINAL ERROR: ValueError: Random error."
-    )
-
-
-def test_pypy_oserror_normalization():
-    # https://github.com/pybind/pybind11/issues/4075
-    what = m.test_pypy_oserror_normalization()
-    assert "this_filename_must_not_exist" in what
-
-
-def test_fn_cast_int_exception():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.test_fn_cast_int(lambda: None)
-
-    assert str(excinfo.value).startswith(
-        "Unable to cast Python instance of type <class 'NoneType'> to C++ type"
-    )
-
-
-def test_return_exception_void():
-    with pytest.raises(TypeError) as excinfo:
-        m.return_exception_void()
-    assert "Exception" in str(excinfo.value)
+import sys
+
+import pytest
+
+import env
+import pybind11_cross_module_tests as cm
+import pybind11_tests
+from pybind11_tests import exceptions as m
+
+
+def test_std_exception(msg):
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throw_std_exception()
+    assert msg(excinfo.value) == "This exception was intentionally thrown."
+
+
+def test_error_already_set(msg):
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throw_already_set(False)
+    assert (
+        msg(excinfo.value)
+        == "Internal error: pybind11::error_already_set called while Python error indicator not set."
+    )
+
+    with pytest.raises(ValueError) as excinfo:
+        m.throw_already_set(True)
+    assert msg(excinfo.value) == "foo"
+
+
+def test_raise_from(msg):
+    with pytest.raises(ValueError) as excinfo:
+        m.raise_from()
+    assert msg(excinfo.value) == "outer"
+    assert msg(excinfo.value.__cause__) == "inner"
+
+
+def test_raise_from_already_set(msg):
+    with pytest.raises(ValueError) as excinfo:
+        m.raise_from_already_set()
+    assert msg(excinfo.value) == "outer"
+    assert msg(excinfo.value.__cause__) == "inner"
+
+
+def test_cross_module_exceptions(msg):
+    with pytest.raises(RuntimeError) as excinfo:
+        cm.raise_runtime_error()
+    assert str(excinfo.value) == "My runtime error"
+
+    with pytest.raises(ValueError) as excinfo:
+        cm.raise_value_error()
+    assert str(excinfo.value) == "My value error"
+
+    with pytest.raises(ValueError) as excinfo:
+        cm.throw_pybind_value_error()
+    assert str(excinfo.value) == "pybind11 value error"
+
+    with pytest.raises(TypeError) as excinfo:
+        cm.throw_pybind_type_error()
+    assert str(excinfo.value) == "pybind11 type error"
+
+    with pytest.raises(StopIteration) as excinfo:
+        cm.throw_stop_iteration()
+
+    with pytest.raises(cm.LocalSimpleException) as excinfo:
+        cm.throw_local_simple_error()
+    assert msg(excinfo.value) == "external mod"
+
+    with pytest.raises(KeyError) as excinfo:
+        cm.throw_local_error()
+    # KeyError is a repr of the key, so it has an extra set of quotes
+    assert str(excinfo.value) == "'just local'"
+
+
+# TODO: FIXME
+@pytest.mark.xfail(
+    "env.MACOS and (env.PYPY or pybind11_tests.compiler_info.startswith('Homebrew Clang'))",
+    raises=RuntimeError,
+    reason="See Issue #2847, PR #2999, PR #4324",
+)
+def test_cross_module_exception_translator():
+    with pytest.raises(KeyError):
+        # translator registered in cross_module_tests
+        m.throw_should_be_translated_to_key_error()
+
+
+def test_python_call_in_catch():
+    d = {}
+    assert m.python_call_in_destructor(d) is True
+    assert d["good"] is True
+
+
+def ignore_pytest_unraisable_warning(f):
+    unraisable = "PytestUnraisableExceptionWarning"
+    if hasattr(pytest, unraisable):  # Python >= 3.8 and pytest >= 6
+        dec = pytest.mark.filterwarnings(f"ignore::pytest.{unraisable}")
+        return dec(f)
+    return f
+
+
+# TODO: find out why this fails on PyPy, https://foss.heptapod.net/pypy/pypy/-/issues/3583
+@pytest.mark.xfail(env.PYPY, reason="Failure on PyPy 3.8 (7.3.7)", strict=False)
+@ignore_pytest_unraisable_warning
+def test_python_alreadyset_in_destructor(monkeypatch, capsys):
+    hooked = False
+    triggered = False
+
+    if hasattr(sys, "unraisablehook"):  # Python 3.8+
+        hooked = True
+        # Don't take `sys.unraisablehook`, as that's overwritten by pytest
+        default_hook = sys.__unraisablehook__
+
+        def hook(unraisable_hook_args):
+            exc_type, exc_value, exc_tb, err_msg, obj = unraisable_hook_args
+            if obj == "already_set demo":
+                nonlocal triggered
+                triggered = True
+            default_hook(unraisable_hook_args)
+            return
+
+        # Use monkeypatch so pytest can apply and remove the patch as appropriate
+        monkeypatch.setattr(sys, "unraisablehook", hook)
+
+    assert m.python_alreadyset_in_destructor("already_set demo") is True
+    if hooked:
+        assert triggered is True
+
+    _, captured_stderr = capsys.readouterr()
+    assert captured_stderr.startswith("Exception ignored in: 'already_set demo'")
+    assert captured_stderr.rstrip().endswith("KeyError: 'bar'")
+
+
+def test_exception_matches():
+    assert m.exception_matches()
+    assert m.exception_matches_base()
+    assert m.modulenotfound_exception_matches_base()
+
+
+def test_custom(msg):
+    # Can we catch a MyException?
+    with pytest.raises(m.MyException) as excinfo:
+        m.throws1()
+    assert msg(excinfo.value) == "this error should go to py::exception<MyException>"
+
+    # Can we catch a MyExceptionUseDeprecatedOperatorCall?
+    with pytest.raises(m.MyExceptionUseDeprecatedOperatorCall) as excinfo:
+        m.throws1d()
+    assert (
+        msg(excinfo.value)
+        == "this error should go to py::exception<MyExceptionUseDeprecatedOperatorCall>"
+    )
+
+    # Can we translate to standard Python exceptions?
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throws2()
+    assert msg(excinfo.value) == "this error should go to a standard Python exception"
+
+    # Can we handle unknown exceptions?
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throws3()
+    assert msg(excinfo.value) == "Caught an unknown exception!"
+
+    # Can we delegate to another handler by rethrowing?
+    with pytest.raises(m.MyException) as excinfo:
+        m.throws4()
+    assert msg(excinfo.value) == "this error is rethrown"
+
+    # Can we fall-through to the default handler?
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throws_logic_error()
+    assert (
+        msg(excinfo.value) == "this error should fall through to the standard handler"
+    )
+
+    # OverFlow error translation.
+    with pytest.raises(OverflowError) as excinfo:
+        m.throws_overflow_error()
+
+    # Can we handle a helper-declared exception?
+    with pytest.raises(m.MyException5) as excinfo:
+        m.throws5()
+    assert msg(excinfo.value) == "this is a helper-defined translated exception"
+
+    # Exception subclassing:
+    with pytest.raises(m.MyException5) as excinfo:
+        m.throws5_1()
+    assert msg(excinfo.value) == "MyException5 subclass"
+    assert isinstance(excinfo.value, m.MyException5_1)
+
+    with pytest.raises(m.MyException5_1) as excinfo:
+        m.throws5_1()
+    assert msg(excinfo.value) == "MyException5 subclass"
+
+    with pytest.raises(m.MyException5) as excinfo:  # noqa: PT012
+        try:
+            m.throws5()
+        except m.MyException5_1 as err:
+            raise RuntimeError("Exception error: caught child from parent") from err
+    assert msg(excinfo.value) == "this is a helper-defined translated exception"
+
+
+def test_nested_throws(capture):
+    """Tests nested (e.g. C++ -> Python -> C++) exception handling"""
+
+    def throw_myex():
+        raise m.MyException("nested error")
+
+    def throw_myex5():
+        raise m.MyException5("nested error 5")
+
+    # In the comments below, the exception is caught in the first step, thrown in the last step
+
+    # C++ -> Python
+    with capture:
+        m.try_catch(m.MyException5, throw_myex5)
+    assert str(capture).startswith("MyException5: nested error 5")
+
+    # Python -> C++ -> Python
+    with pytest.raises(m.MyException) as excinfo:
+        m.try_catch(m.MyException5, throw_myex)
+    assert str(excinfo.value) == "nested error"
+
+    def pycatch(exctype, f, *args):  # noqa: ARG001
+        try:
+            f(*args)
+        except m.MyException as e:
+            print(e)
+
+    # C++ -> Python -> C++ -> Python
+    with capture:
+        m.try_catch(
+            m.MyException5,
+            pycatch,
+            m.MyException,
+            m.try_catch,
+            m.MyException,
+            throw_myex5,
+        )
+    assert str(capture).startswith("MyException5: nested error 5")
+
+    # C++ -> Python -> C++
+    with capture:
+        m.try_catch(m.MyException, pycatch, m.MyException5, m.throws4)
+    assert capture == "this error is rethrown"
+
+    # Python -> C++ -> Python -> C++
+    with pytest.raises(m.MyException5) as excinfo:
+        m.try_catch(m.MyException, pycatch, m.MyException, m.throws5)
+    assert str(excinfo.value) == "this is a helper-defined translated exception"
+
+
+# TODO: Investigate this crash, see pybind/pybind11#5062 for background
+@pytest.mark.skipif(
+    sys.platform.startswith("win32") and "Clang" in pybind11_tests.compiler_info,
+    reason="Started segfaulting February 2024",
+)
+def test_throw_nested_exception():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throw_nested_exception()
+    assert str(excinfo.value) == "Outer Exception"
+    assert str(excinfo.value.__cause__) == "Inner Exception"
+
+
+# This can often happen if you wrap a pybind11 class in a Python wrapper
+def test_invalid_repr():
+    class MyRepr:
+        def __repr__(self):
+            raise AttributeError("Example error")
+
+    with pytest.raises(TypeError):
+        m.simple_bool_passthrough(MyRepr())
+
+
+def test_local_translator(msg):
+    """Tests that a local translator works and that the local translator from
+    the cross module is not applied"""
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throws6()
+    assert msg(excinfo.value) == "MyException6 only handled in this module"
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m.throws_local_error()
+    assert not isinstance(excinfo.value, KeyError)
+    assert msg(excinfo.value) == "never caught"
+
+    with pytest.raises(Exception) as excinfo:
+        m.throws_local_simple_error()
+    assert not isinstance(excinfo.value, cm.LocalSimpleException)
+    assert msg(excinfo.value) == "this mod"
+
+
+def test_error_already_set_message_with_unicode_surrogate():  # Issue #4288
+    assert m.error_already_set_what(RuntimeError, "\ud927") == (
+        "RuntimeError: \\ud927",
+        False,
+    )
+
+
+def test_error_already_set_message_with_malformed_utf8():
+    assert m.error_already_set_what(RuntimeError, b"\x80") == (
+        "RuntimeError: b'\\x80'",
+        False,
+    )
+
+
+class FlakyException(Exception):
+    def __init__(self, failure_point):
+        if failure_point == "failure_point_init":
+            raise ValueError("triggered_failure_point_init")
+        self.failure_point = failure_point
+
+    def __str__(self):
+        if self.failure_point == "failure_point_str":
+            raise ValueError("triggered_failure_point_str")
+        return "FlakyException.__str__"
+
+
+@pytest.mark.parametrize(
+    ("exc_type", "exc_value", "expected_what"),
+    [
+        (ValueError, "plain_str", "ValueError: plain_str"),
+        (ValueError, ("tuple_elem",), "ValueError: tuple_elem"),
+        (FlakyException, ("happy",), "FlakyException: FlakyException.__str__"),
+    ],
+)
+def test_error_already_set_what_with_happy_exceptions(
+    exc_type, exc_value, expected_what
+):
+    what, py_err_set_after_what = m.error_already_set_what(exc_type, exc_value)
+    assert not py_err_set_after_what
+    assert what == expected_what
+
+
+def _test_flaky_exception_failure_point_init_before_py_3_12():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.error_already_set_what(FlakyException, ("failure_point_init",))
+    lines = str(excinfo.value).splitlines()
+    # PyErr_NormalizeException replaces the original FlakyException with ValueError:
+    assert lines[:3] == [
+        "pybind11::error_already_set: MISMATCH of original and normalized active exception types:"
+        " ORIGINAL FlakyException REPLACED BY ValueError: triggered_failure_point_init",
+        "",
+        "At:",
+    ]
+    # Checking the first two lines of the traceback as formatted in error_string():
+    assert "test_exceptions.py(" in lines[3]
+    assert lines[3].endswith("): __init__")
+    assert lines[4].endswith(
+        "): _test_flaky_exception_failure_point_init_before_py_3_12"
+    )
+
+
+def _test_flaky_exception_failure_point_init_py_3_12():
+    # Behavior change in Python 3.12: https://github.com/python/cpython/issues/102594
+    what, py_err_set_after_what = m.error_already_set_what(
+        FlakyException, ("failure_point_init",)
+    )
+    assert not py_err_set_after_what
+    lines = what.splitlines()
+    assert lines[0].endswith("ValueError[WITH __notes__]: triggered_failure_point_init")
+    assert lines[1] == "__notes__ (len=1):"
+    assert "Normalization failed:" in lines[2]
+    assert "FlakyException" in lines[2]
+
+
+@pytest.mark.skipif(
+    "env.PYPY and sys.version_info[:2] < (3, 12)",
+    reason="PyErr_NormalizeException Segmentation fault",
+)
+def test_flaky_exception_failure_point_init():
+    if sys.version_info[:2] < (3, 12):
+        _test_flaky_exception_failure_point_init_before_py_3_12()
+    else:
+        _test_flaky_exception_failure_point_init_py_3_12()
+
+
+def test_flaky_exception_failure_point_str():
+    what, py_err_set_after_what = m.error_already_set_what(
+        FlakyException, ("failure_point_str",)
+    )
+    assert not py_err_set_after_what
+    lines = what.splitlines()
+    n = 3 if env.PYPY and len(lines) == 3 else 5
+    assert (
+        lines[:n]
+        == [
+            "FlakyException: <MESSAGE UNAVAILABLE DUE TO ANOTHER EXCEPTION>",
+            "",
+            "MESSAGE UNAVAILABLE DUE TO EXCEPTION: ValueError: triggered_failure_point_str",
+            "",
+            "At:",
+        ][:n]
+    )
+
+
+def test_cross_module_interleaved_error_already_set():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.test_cross_module_interleaved_error_already_set()
+    assert str(excinfo.value) in (
+        "2nd error.",  # Almost all platforms.
+        "RuntimeError: 2nd error.",  # Some PyPy builds (seen under macOS).
+    )
+
+
+def test_error_already_set_double_restore():
+    m.test_error_already_set_double_restore(True)  # dry_run
+    with pytest.raises(RuntimeError) as excinfo:
+        m.test_error_already_set_double_restore(False)
+    assert str(excinfo.value) == (
+        "Internal error: pybind11::detail::error_fetch_and_normalize::restore()"
+        " called a second time. ORIGINAL ERROR: ValueError: Random error."
+    )
+
+
+def test_pypy_oserror_normalization():
+    # https://github.com/pybind/pybind11/issues/4075
+    what = m.test_pypy_oserror_normalization()
+    assert "this_filename_must_not_exist" in what
+
+
+def test_fn_cast_int_exception():
+    with pytest.raises(RuntimeError) as excinfo:
+        m.test_fn_cast_int(lambda: None)
+
+    assert str(excinfo.value).startswith(
+        "Unable to cast Python instance of type <class 'NoneType'> to C++ type"
+    )
+
+
+def test_return_exception_void():
+    with pytest.raises(TypeError) as excinfo:
+        m.return_exception_void()
+    assert "Exception" in str(excinfo.value)