### ----------------------------------------------------
### -- Format::Lisp
### -- Licenses: Artistic-2.0
### -- Authors: Jeffrey Goff
### -- File: t/18-format-f.rakutest
### ----------------------------------------------------
### -- Chunk 1 of 2
use v6;

use Test;
use lib 't/lib';
use Utils;
use Format::Lisp;

my $*fl = Format::Lisp.new;

# ;;; Equivalent to PRIN1 for 0 or (abs x) in range [10^-3,10^7).
# 
#`(
# (deftest format.f.1
#   (let ((*print-readably* nil)
#         (fn (formatter "~F")))
#     (loop
#      for type in '(short-float single-float double-float long-float
#                    short-float single-float double-float long-float)
#      for x in '(0.0s0 0.0f0 0.0d0 0.0l0
#                       -0.0s0 -0.0f0 -0.0d0 -0.0l0)
#      for s1 = (let ((*read-default-float-format* type)) (format nil "~f" x))
#      for s2 = (let ((*read-default-float-format* type)) (prin1-to-string x))
#      for s3 = (let ((*read-default-float-format* type))
#                 (formatter-call-to-string fn x))
#      unless (and (string= s1 s2) (string= s1 s3))
#      collect (list x type s1 s2 s3)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~F} );
	my @collected;
	for 0.0, -0.0 -> $x { # XXX Not a lot of different types.
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
#	}
	@collected
}, [ ]
), Q{format.f.1};
)

#`(
# (deftest format.f.2
#   (let ((*print-readably* nil)
#         (fn (formatter "~f")))
#     (loop
#      for i = (random 4)
#      for type = (elt #(short-float single-float double-float long-float) i)
#      for x = (expt (coerce 10 type)
#                    (- (random 10.0s0) 3))
#      for s1 = (let ((*read-default-float-format* type)) (format nil "~f" x))
#      for s2 = (let ((*read-default-float-format* type)) (prin1-to-string x))
#      for s3 = (let ((*read-default-float-format* type))
#                 (formatter-call-to-string fn x))
#      repeat 1000
#      when (and (<= 1/1000 x)
#                (< x 10000000)
#                (or (not (string= s1 s2))
#                    (not (string= s1 s3))))
#      collect (list x s1 s2 s3)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~f} );
	my @collected;
	for 1 .. 1000 {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.2};
)

#`(
# (deftest format.f.3
#   (let ((*print-readably* nil)
#         (fn (formatter "~F")))
#     (loop
#      for i = (random 4)
#      for type = (elt #(short-float single-float double-float long-float) i)
#      for x = (- (expt (coerce 10 type)
#                       (- (random 10.0s0) 3)))
#      for s1 = (let ((*read-default-float-format* type)) (format nil "~f" x))
#      for s2 = (let ((*read-default-float-format* type)) (prin1-to-string x))
#      for s3 = (let ((*read-default-float-format* type))
#                 (formatter-call-to-string fn x))
#      repeat 1000
#      when (and (>= -1/1000 x)
#                (> x -10000000)
#                (not (and (string= s1 s2) (string= s1 s3))))
#      collect (list x s1 s2 s3)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~F} );
	my @collected;
	for 1 .. 1000 {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.3};
)

#`(
# (deftest format.f.4
#   (let ((fn (formatter "~3f")))
#     (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
#           for s = (format nil "~3f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "1.0") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~3f} );
	my @collected;
	for 1, 1.0 -> $x {
#	for @standard-chars -> $c {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.4};
)

#`(
# (deftest format.f.5
#   (let ((fn (formatter "~2f")))
#     (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
#           for s = (format nil "~2f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "1.0") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~2f} );
	my @collected;
	for 1, 1.0 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.5};
)

#`(
# (deftest format.f.6
#   (let ((fn (formatter "~4F")))
#     (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
#           for s = (format nil "~4F" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s " 1.0") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4F} );
	my @collected;
	for 1, 1.0 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.6};
)

#`(
# (deftest format.f.7
#   (let ((fn (formatter "~4@F")))
#     (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
#           for s = (format nil "~4@f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "+1.0") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4@F} );
	my @collected;
	for 1, 1.0 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.7};
)

#`(
# (deftest format.f.8
#   (let ((fn (formatter "~3@F")))
#     (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
#           for s = (format nil "~3@F" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "+1.0") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~3@F} );
	my @collected;
	for 1, 1.0 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.8};
)

#`(
# (deftest format.f.9
#   (let ((fn (formatter "~4f")))
#     (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0))
#           for s = (format nil "~4f" (- x))
#           for s2 = (formatter-call-to-string fn (- x))
#           unless (and (string= s "-1.0") (string= s s2))
#           collect (list (- x) s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4f} );
	my @collected;
	for 1, 1.0 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.9};
)

#`(
# (deftest format.f.10
#   (let ((fn (formatter "~3F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~3f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "0.5") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~3F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.10};
)

#`(
# (deftest format.f.11
#   (let ((fn (formatter "~4f")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~4f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s " 0.5") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4f} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.11};
)

#`(
# (deftest format.f.12
#   (let ((fn (formatter "~4,2F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~4,2f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "0.50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4,2F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.12};
)

#`(
# (deftest format.f.13
#   (let ((fn (formatter "~3,2F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~3,2f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s ".50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~3,2F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.13};
)

#`(
# (deftest format.f.14
#   (let ((fn (formatter "~2,1F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~2,1f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s ".5") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~2,1F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.14};
)

#`(
# (deftest format.f.15
#   (let ((fn (formatter "~4,2@F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~4,2@f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "+.50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4,2@F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.15};
)

#`(
# (deftest format.f.16
#   (let ((fn (formatter "~2,2F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~2,2f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s ".50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~2,2F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.16};
)

#`(
# (deftest format.f.17
#   (let ((fn (formatter "~,2F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~,2f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "0.50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~,2F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.17};
)

#`(
# (deftest format.f.18
#   (let ((fn (formatter "~,2F")))
#     (loop for xn in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for x = (- xn)
#           for s = (format nil "~,2f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "-0.50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~,2F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.18};
)

#`(
# (deftest format.f.19
#   (let ((fn (formatter "~4,2,-1F")))
#     (loop for x in (remove-duplicates '(5 5.0s0 5.0f0 5.0d0 5.0l0))
#           for s = (format nil "~4,2,-1f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "0.50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4,2,-1F} );
	my @collected;
	for 5, 5.0 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.19};
)

#`(
# (deftest format.f.20
#   (let ((fn (formatter "~4,2,0F")))
#     (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0))
#           for s = (format nil "~4,2,0f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "0.50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4,2,0F} );
	my @collected;
	for 1/2, 0.5 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.20};
)

#`(
# (deftest format.f.21
#   (let ((fn (formatter "~4,2,1f")))
#     (loop for x in (remove-duplicates '(1/20 0.05s0 0.05f0 0.05d0 0.05l0))
#           for s = (format nil "~4,2,1f" x)
#           for s2 = (formatter-call-to-string fn x)
#           unless (and (string= s "0.50") (string= s s2))
#           collect (list x s s2)))
#   nil)
# 
ok deftest( {
	my $fn = $*fl.formatter( Q{~4,2,1f} );
	my @collected;
	for 1/20, 0.05 -> $x {
#		my $s1 = $c;
#		my $s2 = $*fl.format( Q{~a}, $s1 );
#		my $s3 = formatter-call-to-string( $fn, $s1 );
#		unless $s1 eq $s1 and $s2 eq $s3 {
#			@collected.append( [ $c, $s1, $s2, $s3 ] );
#		}
	}
	@collected;
}, [ ]
), Q{format.f.21};
)

subtest {
	1;
	#`(
	# (deftest format.f.22
	#   (let ((fn (formatter "~5,1,,'*F")))
	#     (loop for x in (remove-duplicates
	#                     '(1000 1000.0s0 1000.0f0 1000.0d0 1000.0l0))
	#           for s = (format nil "~5,1,,'*f" x)
	#           for s2 = (formatter-call-to-string fn x)
	#           unless (and (string= s "*****") (string= s s2))
	#           collect (list x s s2)))
	#   nil)
	# 
	ok deftest( {
		my $fn = $*fl.formatter( Q{~5,1,,'*F} );
		my @collected;
		for 1000, 1000.0 -> $x {
	#		my $s1 = $c;
	#		my $s2 = $*fl.format( Q{~a}, $s1 );
	#		my $s3 = formatter-call-to-string( $fn, $s1 );
	#		unless $s1 eq $s1 and $s2 eq $s3 {
	#			@collected.append( [ $c, $s1, $s2, $s3 ] );
	#		}
		}
		@collected;
	}, [ ]
	), Q{format.f.22};
	)

	#`(
	# (deftest format.f.23
	#   (let ((fn (formatter "~5,1,,'*f")))
	#     (loop for x in (remove-duplicates
	#                     '(100 100.0s0 100.0f0 100.0d0 100.0l0))
	#           for s = (format nil "~5,1,,'*f" x)
	#           for s2 = (formatter-call-to-string fn x)
	#           unless (and (string= s "100.0") (string= s s2))
	#           collect (list x s s2)))
	#   nil)
	# 
	ok deftest( {
		my $fn = $*fl.formatter( Q{~5,1,,'*f} );
		my @collected;
		for 100, 100.0 -> $x {
	#		my $s1 = $c;
	#		my $s2 = $*fl.format( Q{~a}, $s1 );
	#		my $s3 = formatter-call-to-string( $fn, $s1 );
	#		unless $s1 eq $s1 and $s2 eq $s3 {
	#			@collected.append( [ $c, $s1, $s2, $s3 ] );
	#		}
		}
		@collected;
	}, [ ]
	), Q{format.f.23};
	)

	#`(
	# (deftest format.f.24
	#   (let ((fn (formatter "~4,0,,'*F")))
	#     (loop for x in (remove-duplicates
	#                     '(100 100.0s0 100.0f0 100.0d0 100.0l0))
	#           for s = (format nil "~4,0,,'*f" x)
	#           for s2 = (formatter-call-to-string fn x)
	#           unless (and (string= s "100.") (string= s s2))
	#           collect (list x s s2)))
	#   nil)
	# 
	ok deftest( {
		my $fn = $*fl.formatter( Q{~4,0,,'*F} );
		my @collected;
		for 100, 100.0 -> $x {
	#		my $s1 = $c;
	#		my $s2 = $*fl.format( Q{~a}, $s1 );
	#		my $s3 = formatter-call-to-string( $fn, $s1 );
	#		unless $s1 eq $s1 and $s2 eq $s3 {
	#			@collected.append( [ $c, $s1, $s2, $s3 ] );
	#		}
		}
		@collected;
	}, [ ]
	), Q{format.f.24};
	)

	#`(
	# (deftest format.f.25
	#   (let ((fn (formatter "~1,1,,f")))
	#     (loop for x in (remove-duplicates
	#                     '(100 100.0s0 100.0f0 100.0d0 100.0l0))
	#           for s = (format nil "~1,1,,f" x)
	#           for s2 = (formatter-call-to-string fn x)
	#           unless (and (string= s "100.0") (string= s s2))
	#           collect (list x s s2)))
	#   nil)
	# 
	ok deftest( {
		my $fn = $*fl.formatter( Q{~1,1,,f} );
		my @collected;
		for 100, 100.0 -> $x {
	#		my $s1 = $c;
	#		my $s2 = $*fl.format( Q{~a}, $s1 );
	#		my $s3 = formatter-call-to-string( $fn, $s1 );
	#		unless $s1 eq $s1 and $s2 eq $s3 {
	#			@collected.append( [ $c, $s1, $s2, $s3 ] );
	#		}
		}
		@collected;
	}, [ ]
	), Q{format.f.25};
	)
}, Q{overflow};

subtest {
	1;
	#`(
	# (deftest format.f.26
	#   (let ((fn (formatter "~10,1,,f")))
	#     (loop for x in (remove-duplicates
	#                     '(100 100.0s0 100.0f0 100.0d0 100.0l0))
	#           for s = (format nil "~10,1,,f" x)
	#           for s2 = (formatter-call-to-string