Source: node-d3-shape
Version: 1.3.7-2
Severity: serious
Justification: FTBFS
Tags: bookworm sid ftbfs
User: lu...@debian.org
Usertags: ftbfs-20211023 ftbfs-bookworm
Hi,
During a rebuild of all packages in sid, your package failed to build
on amd64.
Relevant part (hopefully):
> make[1]: Entering directory '/<<PKGBUILDDIR>>'
> rollup -c
>
> src/index.js → dist/d3-shape.js...
> created dist/d3-shape.js in 275ms
>
> src/index.js → dist/d3-shape.min.js...
> created dist/d3-shape.min.js in 1s
> make[1]: Leaving directory '/<<PKGBUILDDIR>>'
> dh_auto_test --buildsystem=nodejs
> mkdir -p node_modules
> ln -s ../. node_modules/d3-shape
> /bin/sh -ex debian/tests/pkg-js/test
> + tape test/**/*.js
> TAP version 13
> # arc().innerRadius(f)(…) propagates the context and arguments to the
> specified function f
> ok 1 should be deeply equivalent
> # arc().outerRadius(f)(…) propagates the context and arguments to the
> specified function f
> ok 2 should be deeply equivalent
> # arc().cornerRadius(f)(…) propagates the context and arguments to the
> specified function f
> ok 3 should be deeply equivalent
> # arc().startAngle(f)(…) propagates the context and arguments to the
> specified function f
> ok 4 should be deeply equivalent
> # arc().endAngle(f)(…) propagates the context and arguments to the specified
> function f
> ok 5 should be deeply equivalent
> # arc().padAngle(f)(…) propagates the context and arguments to the specified
> function f
> ok 6 should be deeply equivalent
> # arc().padRadius(f)(…) propagates the context and arguments to the specified
> function f
> ok 7 should be deeply equivalent
> # arc().centroid(…) computes the midpoint of the center line of the arc
> ok 8 should be deeply equivalent
> ok 9 should be deeply equivalent
> not ok 10 should be deeply equivalent
> ---
> operator: deepEqual
> expected: |-
> [ -75, 0 ]
> actual: |-
> [ -75, -0 ]
> at: Test.<anonymous> (/<<PKGBUILDDIR>>/test/arc-test.js:59:8)
> stack: |-
> Error: should be deeply equivalent
> at Test.assert [as _assert]
> (/usr/share/nodejs/tape/lib/test.js:311:54)
> at Test.bound [as _assert]
> (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Test.tapeDeepEqual (/usr/share/nodejs/tape/lib/test.js:552:10)
> at Test.bound [as deepEqual]
> (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Test.<anonymous> (/<<PKGBUILDDIR>>/test/arc-test.js:59:8)
> at Test.bound [as _cb] (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Test.run (/usr/share/nodejs/tape/lib/test.js:114:31)
> at Test.bound [as run] (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Immediate.next [as _onImmediate]
> (/usr/share/nodejs/tape/lib/results.js:88:19)
> at processImmediate (internal/timers.js:461:21)
> ...
> ok 11 should be deeply equivalent
> # arc().innerRadius(f).centroid(…) propagates the context and arguments to
> the specified function f
> ok 12 should be deeply equivalent
> # arc().outerRadius(f).centroid(…) propagates the context and arguments to
> the specified function f
> ok 13 should be deeply equivalent
> # arc().startAngle(f).centroid(…) propagates the context and arguments to the
> specified function f
> ok 14 should be deeply equivalent
> # arc().endAngle(f).centroid(…) propagates the context and arguments to the
> specified function f
> ok 15 should be deeply equivalent
> # arc().innerRadius(0).outerRadius(0) renders a point
> ok 16 should be equal
> ok 17 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁) renders a
> clockwise circle if r > 0 and θ₁ - θ₀ ≥ τ
> ok 18 should be equal
> ok 19 should be equal
> ok 20 should be equal
> ok 21 should be equal
> ok 22 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁) renders an
> anticlockwise circle if r > 0 and θ₀ - θ₁ ≥ τ
> ok 23 should be equal
> ok 24 should be equal
> ok 25 should be equal
> ok 26 should be equal
> ok 27 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁) renders a
> clockwise annulus if r₀ > 0, r₁ > 0 and θ₀ - θ₁ ≥ τ
> ok 28 should be equal
> ok 29 should be equal
> ok 30 should be equal
> ok 31 should be equal
> ok 32 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁) renders
> an anticlockwise annulus if r₀ > 0, r₁ > 0 and θ₁ - θ₀ ≥ τ
> ok 33 should be equal
> ok 34 should be equal
> ok 35 should be equal
> ok 36 should be equal
> ok 37 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁) renders a
> small clockwise sector if r > 0 and π > θ₁ - θ₀ ≥ 0
> ok 38 should be equal
> ok 39 should be equal
> ok 40 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁) renders a
> small anticlockwise sector if r > 0 and π > θ₀ - θ₁ ≥ 0
> ok 41 should be equal
> ok 42 should be equal
> ok 43 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁) renders a
> large clockwise sector if r > 0 and τ > θ₁ - θ₀ ≥ π
> ok 44 should be equal
> ok 45 should be equal
> ok 46 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁) renders a
> large anticlockwise sector if r > 0 and τ > θ₀ - θ₁ ≥ π
> ok 47 should be equal
> ok 48 should be equal
> ok 49 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁) renders a
> small clockwise annular sector if r₀ > 0, r₁ > 0 and π > θ₁ - θ₀ ≥ 0
> ok 50 should be equal
> ok 51 should be equal
> ok 52 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁) renders a
> small anticlockwise annular sector if r₀ > 0, r₁ > 0 and π > θ₀ - θ₁ ≥ 0
> ok 53 should be equal
> ok 54 should be equal
> ok 55 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁) renders a
> large clockwise annular sector if r₀ > 0, r₁ > 0 and τ > θ₁ - θ₀ ≥ π
> ok 56 should be equal
> ok 57 should be equal
> ok 58 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁) renders a
> large anticlockwise annular sector if r₀ > 0, r₁ > 0 and τ > θ₀ - θ₁ ≥ π
> ok 59 should be equal
> ok 60 should be equal
> ok 61 should be equal
> # arc().innerRadius(0).outerRadius(0).cornerRadius(r) renders a point
> ok 62 should be equal
> ok 63 should be equal
> #
> arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a clockwise circle if r > 0 and θ₁ - θ₀ ≥ τ
> ok 64 should be equal
> ok 65 should be equal
> ok 66 should be equal
> ok 67 should be equal
> ok 68 should be equal
> #
> arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders an anticlockwise circle if r > 0 and θ₀ - θ₁ ≥ τ
> ok 69 should be equal
> ok 70 should be equal
> ok 71 should be equal
> ok 72 should be equal
> ok 73 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a clockwise annulus if r₀ > 0, r₁ > 0 and θ₀ - θ₁ ≥ τ
> ok 74 should be equal
> ok 75 should be equal
> ok 76 should be equal
> ok 77 should be equal
> ok 78 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders an anticlockwise annulus if r₀ > 0, r₁ > 0 and θ₁ - θ₀ ≥ τ
> ok 79 should be equal
> ok 80 should be equal
> ok 81 should be equal
> ok 82 should be equal
> ok 83 should be equal
> #
> arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a small clockwise sector if r > 0 and π > θ₁ - θ₀ ≥ 0
> ok 84 should be equal
> ok 85 should be equal
> ok 86 should be equal
> #
> arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a small anticlockwise sector if r > 0 and π > θ₀ - θ₁ ≥ 0
> ok 87 should be equal
> ok 88 should be equal
> ok 89 should be equal
> #
> arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a large clockwise sector if r > 0 and τ > θ₁ - θ₀ ≥ π
> ok 90 should be equal
> ok 91 should be equal
> ok 92 should be equal
> #
> arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a large anticlockwise sector if r > 0 and τ > θ₀ - θ₁ ≥ π
> ok 93 should be equal
> ok 94 should be equal
> ok 95 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a small clockwise annular sector if r₀ > 0, r₁ > 0 and π > θ₁ - θ₀ ≥ > 0
> ok 96 should be equal
> ok 97 should be equal
> ok 98 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a small anticlockwise annular sector if r₀ > 0, r₁ > 0 and π > θ₀ -
> θ₁ ≥ 0
> ok 99 should be equal
> ok 100 should be equal
> ok 101 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a large clockwise annular sector if r₀ > 0, r₁ > 0 and τ > θ₁ - θ₀ ≥
> π
> ok 102 should be equal
> ok 103 should be equal
> ok 104 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).cornerRadius(rᵧ)
> renders a large anticlockwise annular sector if r₀ > 0, r₁ > 0 and τ > θ₀ -
> θ₁ ≥ π
> ok 105 should be equal
> ok 106 should be equal
> ok 107 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).cornerRadius(rᵧ) restricts rᵧ to |r₁
> - r₀| / 2
> ok 108 should be equal
> ok 109 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).cornerRadius(rᵧ) merges adjacent
> corners when rᵧ is relatively large
> ok 110 should be equal
> ok 111 should be equal
> # arc().innerRadius(0).outerRadius(0).startAngle(0).endAngle(τ).padAngle(δ)
> does not pad a point
> ok 112 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(0).endAngle(τ).padAngle(δ)
> does not pad a circle
> ok 113 should be equal
> # arc().innerRadius(r₀).outerRadius(r₁).startAngle(0).endAngle(τ).padAngle(δ)
> does not pad an annulus
> ok 114 should be equal
> # arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).padAngle(δ)
> pads the outside of a circular sector
> ok 115 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).padAngle(δ)
> pads an annular sector
> ok 116 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).padAngle(δ)
> may collapse the inside of an annular sector
> ok 117 should be equal
> #
> arc().innerRadius(0).outerRadius(r).startAngle(θ₀).endAngle(θ₁).padAngle(δ).cornerRadius(rᵧ)
> rounds and pads a circular sector
> ok 118 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).padAngle(δ).cornerRadius(rᵧ)
> rounds and pads an annular sector
> ok 119 should be equal
> #
> arc().innerRadius(r₀).outerRadius(r₁).startAngle(θ₀).endAngle(θ₁).padAngle(δ).cornerRadius(rᵧ)
> rounds and pads a collapsed annular sector
> ok 120 should be equal
> # area() returns a default area shape
> ok 121 should be strictly equal
> ok 122 should be strictly equal
> ok 123 should be strictly equal
> ok 124 should be strictly equal
> ok 125 should be strictly equal
> ok 126 should be strictly equal
> ok 127 should be strictly equal
> ok 128 should be equal
> # area.x(f)(data) passes d, i and data to the specified function f
> ok 129 should be deeply equivalent
> # area.x0(f)(data) passes d, i and data to the specified function f
> ok 130 should be deeply equivalent
> # area.x1(f)(data) passes d, i and data to the specified function f
> ok 131 should be deeply equivalent
> # area.y(f)(data) passes d, i and data to the specified function f
> ok 132 should be deeply equivalent
> # area.y0(f)(data) passes d, i and data to the specified function f
> ok 133 should be deeply equivalent
> # area.y1(f)(data) passes d, i and data to the specified function f
> ok 134 should be deeply equivalent
> # area.defined(f)(data) passes d, i and data to the specified function f
> ok 135 should be deeply equivalent
> # area.x(x)(data) observes the specified function
> ok 136 should be strictly equal
> ok 137 should be strictly equal
> ok 138 should be strictly equal
> ok 139 should be equal
> # area.x(x)(data) observes the specified constant
> ok 140 should be strictly equal
> ok 141 should be strictly equal
> ok 142 should be strictly equal
> ok 143 should be equal
> # area.y(y)(data) observes the specified function
> ok 144 should be strictly equal
> ok 145 should be strictly equal
> ok 146 should be strictly equal
> ok 147 should be equal
> # area.y(y)(data) observes the specified constant
> ok 148 should be strictly equal
> ok 149 should be strictly equal
> ok 150 should be strictly equal
> ok 151 should be equal
> # area.curve(curve) sets the curve method
> ok 152 should be equal
> # area.curve(curveCardinal.tension(tension)) sets the cardinal spline tension
> ok 153 should be strictly equal
> ok 154 should be equal
> ok 155 should be equal
> ok 156 should be equal
> ok 157 should be equal
> # area.curve(curveCardinal.tension(tension)) coerces the specified tension to
> a number
> ok 158 should be strictly equal
> ok 159 should be equal
> ok 160 should be equal
> ok 161 should be equal
> ok 162 should be equal
> # area.lineX0() returns a line derived from the area
> ok 163 should be strictly equal
> ok 164 should be strictly equal
> ok 165 should be strictly equal
> ok 166 should be strictly equal
> ok 167 should be strictly equal
> # area.lineX1() returns a line derived from the area
> ok 168 should be strictly equal
> ok 169 should be strictly equal
> ok 170 should be strictly equal
> ok 171 should be strictly equal
> ok 172 should be strictly equal
> # area.lineY0() returns a line derived from the area
> ok 173 should be strictly equal
> ok 174 should be strictly equal
> ok 175 should be strictly equal
> ok 176 should be strictly equal
> ok 177 should be strictly equal
> # area.lineY1() returns a line derived from the area
> ok 178 should be strictly equal
> ok 179 should be strictly equal
> ok 180 should be strictly equal
> ok 181 should be strictly equal
> ok 182 should be strictly equal
> # areaRadial() returns a default radial area shape
> ok 183 should be strictly equal
> ok 184 should be strictly equal
> ok 185 should be strictly equal
> ok 186 should be strictly equal
> ok 187 should be strictly equal
> ok 188 should be strictly equal
> ok 189 should be strictly equal
> ok 190 should be equal
> # areaRadial.lineStartAngle() returns a line derived from the area
> ok 191 should be strictly equal
> ok 192 should be strictly equal
> ok 193 should be strictly equal
> ok 194 should be strictly equal
> ok 195 should be strictly equal
> # areaRadial.lineEndAngle() returns a line derived from the area
> ok 196 should be strictly equal
> ok 197 should be strictly equal
> ok 198 should be strictly equal
> ok 199 should be strictly equal
> ok 200 should be strictly equal
> # areaRadial.lineInnerRadius() returns a line derived from the area
> ok 201 should be strictly equal
> ok 202 should be strictly equal
> ok 203 should be strictly equal
> ok 204 should be strictly equal
> ok 205 should be strictly equal
> # areaRadial.lineOuterRadius() returns a line derived from the area
> ok 206 should be strictly equal
> ok 207 should be strictly equal
> ok 208 should be strictly equal
> ok 209 should be strictly equal
> ok 210 should be strictly equal
> # line.curve(curveBasis)(data) generates the expected path
> ok 211 should be strictly equal
> ok 212 should be equal
> ok 213 should be equal
> ok 214 should be equal
> # area.curve(curveBasis)(data) generates the expected path
> ok 215 should be strictly equal
> ok 216 should be equal
> ok 217 should be equal
> ok 218 should be equal
> # line.curve(curveBasisClosed)(data) generates the expected path
> ok 219 should be strictly equal
> ok 220 should be equal
> ok 221 should be equal
> ok 222 should be equal
> ok 223 should be equal
> ok 224 should be equal
> # line.curve(curveBasisOpen)(data) generates the expected path
> ok 225 should be strictly equal
> ok 226 should be strictly equal
> ok 227 should be strictly equal
> ok 228 should be equal
> ok 229 should be equal
> ok 230 should be equal
> # area.curve(curveBasisOpen)(data) generates the expected path
> ok 231 should be strictly equal
> ok 232 should be strictly equal
> ok 233 should be strictly equal
> ok 234 should be equal
> ok 235 should be equal
> ok 236 should be equal
> # line.curve(curveBundle) uses a default beta of 0.85
> ok 237 should be strictly equal
> # line.curve(curveBundle.beta(beta)) uses the specified beta
> ok 238 should be strictly equal
> # line.curve(curveBundle.beta(beta)) coerces the specified beta to a number
> ok 239 should be strictly equal
> # line.curve(curveCardinal)(data) generates the expected path
> ok 240 should be strictly equal
> ok 241 should be equal
> ok 242 should be equal
> ok 243 should be equal
> ok 244 should be equal
> # line.curve(curveCardinal) uses a default tension of zero
> ok 245 should be strictly equal
> # line.curve(curveCardinal.tension(tension)) uses the specified tension
> ok 246 should be equal
> # line.curve(curveCardinal.tension(tension)) coerces the specified tension to
> a number
> ok 247 should be strictly equal
> # area.curve(curveCardinal)(data) generates the expected path
> ok 248 should be strictly equal
> ok 249 should be equal
> ok 250 should be equal
> ok 251 should be equal
> ok 252 should be equal
> # area.curve(curveCardinal) uses a default tension of zero
> ok 253 should be strictly equal
> # area.curve(curveCardinal.tension(tension)) uses the specified tension
> ok 254 should be equal
> # area.curve(curveCardinal.tension(tension)) coerces the specified tension to
> a number
> ok 255 should be strictly equal
> # line.curve(curveCardinalClosed)(data) generates the expected path
> ok 256 should be strictly equal
> ok 257 should be equal
> ok 258 should be equal
> ok 259 should be equal
> ok 260 should be equal
> # line.curve(curveCardinalClosed) uses a default tension of zero
> ok 261 should be strictly equal
> # line.curve(curveCardinalClosed.tension(tension)) uses the specified tension
> ok 262 should be equal
> # line.curve(curveCardinalClosed.tension(tension)) coerces the specified
> tension to a number
> ok 263 should be strictly equal
> # area.curve(curveCardinalClosed)(data) generates the expected path
> ok 264 should be strictly equal
> ok 265 should be strictly equal
> ok 266 should be strictly equal
> ok 267 should be equal
> ok 268 should be equal
> # area.curve(curveCardinalClosed) uses a default tension of zero
> ok 269 should be strictly equal
> # area.curve(curveCardinalClosed.tension(tension)) uses the specified tension
> ok 270 should be equal
> # area.curve(curveCardinalClosed.tension(tension)) coerces the specified
> tension to a number
> ok 271 should be strictly equal
> # line.curve(curveCardinalOpen)(data) generates the expected path
> ok 272 should be strictly equal
> ok 273 should be strictly equal
> ok 274 should be strictly equal
> ok 275 should be equal
> ok 276 should be equal
> # line.curve(curveCardinalOpen) uses a default tension of zero
> ok 277 should be strictly equal
> # line.curve(curveCardinalOpen.tension(tension)) uses the specified tension
> ok 278 should be equal
> # line.curve(curveCardinalOpen.tension(tension)) coerces the specified
> tension to a number
> ok 279 should be strictly equal
> # area.curve(curveCardinalOpen)(data) generates the expected path
> ok 280 should be strictly equal
> ok 281 should be strictly equal
> ok 282 should be strictly equal
> ok 283 should be equal
> ok 284 should be equal
> # area.curve(curveCardinalOpen) uses a default tension of zero
> ok 285 should be strictly equal
> # area.curve(curveCardinalOpen.tension(tension)) uses the specified tension
> ok 286 should be equal
> # area.curve(curveCardinalOpen.tension(tension)) coerces the specified
> tension to a number
> ok 287 should be strictly equal
> # line.curve(curveCatmullRom)(data) generates the expected path
> ok 288 should be strictly equal
> ok 289 should be equal
> ok 290 should be equal
> ok 291 should be equal
> ok 292 should be equal
> # line.curve(curveCatmullRom.alpha(1))(data) generates the expected path
> ok 293 should be strictly equal
> ok 294 should be equal
> ok 295 should be equal
> ok 296 should be equal
> ok 297 should be equal
> # line.curve(curveCatmullRom) uses a default alpha of 0.5 (centripetal)
> ok 298 should be strictly equal
> # line.curve(curveCatmullRom.alpha(alpha)) coerces the specified alpha to a
> number
> ok 299 should be strictly equal
> # area.curve(curveCatmullRom.alpha(0))(data) generates the expected path
> ok 300 should be strictly equal
> ok 301 should be equal
> ok 302 should be equal
> ok 303 should be equal
> ok 304 should be equal
> # area.curve(curveCatmullRom) uses a default alpha of 0.5 (centripetal)
> ok 305 should be strictly equal
> # area.curve(curveCatmullRom.alpha(alpha)) coerces the specified alpha to a
> number
> ok 306 should be strictly equal
> # line.curve(curveCatmullRomClosed)(data) generates the expected path
> ok 307 should be strictly equal
> ok 308 should be equal
> ok 309 should be equal
> ok 310 should be equal
> ok 311 should be equal
> # line.curve(curveCatmullRomClosed.alpha(0))(data) generates the expected path
> ok 312 should be strictly equal
> ok 313 should be equal
> ok 314 should be equal
> ok 315 should be equal
> ok 316 should be equal
> # line.curve(curveCatmullRomClosed.alpha(1))(data) generates the expected path
> ok 317 should be strictly equal
> ok 318 should be equal
> ok 319 should be equal
> ok 320 should be equal
> ok 321 should be equal
> # line.curve(curveCatmullRomClosed) uses a default alpha of 0.5 (centripetal)
> ok 322 should be strictly equal
> # line.curve(curveCatmullRomClosed.alpha(alpha)) coerces the specified alpha
> to a number
> ok 323 should be strictly equal
> # area.curve(curveCatmullRomClosed.alpha(alpha)) coerces the specified alpha
> to a number
> ok 324 should be strictly equal
> # line.curve(curveCatmullRomOpen)(data) generates the expected path
> ok 325 should be strictly equal
> ok 326 should be strictly equal
> ok 327 should be strictly equal
> ok 328 should be equal
> ok 329 should be equal
> # line.curve(curveCatmullRomOpen.alpha(1))(data) generates the expected path
> ok 330 should be strictly equal
> ok 331 should be strictly equal
> ok 332 should be strictly equal
> ok 333 should be equal
> ok 334 should be equal
> # line.curve(curveCatmullRomOpen) uses a default alpha of 0.5 (centripetal)
> ok 335 should be strictly equal
> # line.curve(curveCatmullRom.alpha(alpha)) coerces the specified alpha to a
> number
> ok 336 should be strictly equal
> # area.curve(curveCatmullRomOpen.alpha(0.5))(data) generates the expected path
> ok 337 should be strictly equal
> ok 338 should be strictly equal
> ok 339 should be strictly equal
> ok 340 should be equal
> ok 341 should be equal
> # area.curve(curveCatmullRomOpen) uses a default alpha of 0.5 (centripetal)
> ok 342 should be strictly equal
> # area.curve(curveCatmullRomOpen.alpha(alpha)) coerces the specified alpha to
> a number
> ok 343 should be strictly equal
> # line.curve(curveLinear)(data) generates the expected path
> ok 344 should be strictly equal
> ok 345 should be equal
> ok 346 should be equal
> ok 347 should be equal
> # area.curve(curveLinear)(data) generates the expected path
> ok 348 should be strictly equal
> ok 349 should be equal
> ok 350 should be equal
> ok 351 should be equal
> # line.curve(curveLinearClosed)(data) generates the expected path
> ok 352 should be strictly equal
> ok 353 should be equal
> ok 354 should be equal
> ok 355 should be equal
> # line.curve(curveMonotoneX)(data) generates the expected path
> ok 356 should be strictly equal
> ok 357 should be equal
> ok 358 should be equal
> ok 359 should be equal
> ok 360 should be equal
> # line.curve(curveMonotoneX)(data) preserves monotonicity in y
> ok 361 should be equal
> # line.curve(curveMonotoneX)(data) handles duplicate x-values
> ok 362 should be equal
> ok 363 should be equal
> ok 364 should be equal
> # line.curve(curveMonotoneX)(data) handles segments of infinite slope
> ok 365 should be equal
> ok 366 should be equal
> # line.curve(curveMonotoneX)(data) ignores coincident points
> ok 367 should be strictly equal
> ok 368 should be strictly equal
> ok 369 should be strictly equal
> ok 370 should be strictly equal
> ok 371 should be strictly equal
> # area.curve(curveMonotoneX)(data) generates the expected path
> ok 372 should be strictly equal
> ok 373 should be equal
> ok 374 should be equal
> ok 375 should be equal
> ok 376 should be equal
> # line.curve(curveMonotoneY)(data) generates the expected path
> ok 377 should be strictly equal
> ok 378 should be equal
> ok 379 should be equal
> ok 380 should be equal
> ok 381 should be equal
> # line.curve(curveMonotoneY)(data) preserves monotonicity in y
> ok 382 should be equal
> # line.curve(curveMonotoneY)(data) handles duplicate x-values
> ok 383 should be equal
> ok 384 should be equal
> ok 385 should be equal
> # line.curve(curveMonotoneY)(data) handles segments of infinite slope
> ok 386 should be equal
> ok 387 should be equal
> # line.curve(curveMonotoneY)(data) ignores coincident points
> ok 388 should be strictly equal
> ok 389 should be strictly equal
> ok 390 should be strictly equal
> ok 391 should be strictly equal
> ok 392 should be strictly equal
> # area.curve(curveMonotoneY)(data) generates the expected path
> ok 393 should be strictly equal
> ok 394 should be equal
> ok 395 should be equal
> ok 396 should be equal
> ok 397 should be equal
> # line.curve(curveNatural)(data) generates the expected path
> ok 398 should be strictly equal
> ok 399 should be equal
> ok 400 should be equal
> ok 401 should be equal
> ok 402 should be equal
> # area.curve(curveNatural)(data) generates the expected path
> ok 403 should be strictly equal
> ok 404 should be equal
> ok 405 should be equal
> ok 406 should be equal
> ok 407 should be equal
> # line.curve(curveStep)(data) generates the expected path
> ok 408 should be strictly equal
> ok 409 should be equal
> ok 410 should be equal
> ok 411 should be equal
> # area.curve(curveStep)(data) generates the expected path
> ok 412 should be strictly equal
> ok 413 should be equal
> ok 414 should be equal
> ok 415 should be equal
> # line.curve(curveStepAfter)(data) generates the expected path
> ok 416 should be strictly equal
> ok 417 should be equal
> ok 418 should be equal
> ok 419 should be equal
> # area.curve(curveStepAfter)(data) generates the expected path
> ok 420 should be strictly equal
> ok 421 should be equal
> ok 422 should be equal
> ok 423 should be equal
> # line.curve(curveStepBefore)(data) generates the expected path
> ok 424 should be strictly equal
> ok 425 should be equal
> ok 426 should be equal
> ok 427 should be equal
> # area.curve(curveStepBefore)(data) generates the expected path
> ok 428 should be strictly equal
> ok 429 should be equal
> ok 430 should be equal
> ok 431 should be equal
> # line() returns a default line shape
> ok 432 should be strictly equal
> ok 433 should be strictly equal
> ok 434 should be strictly equal
> ok 435 should be strictly equal
> ok 436 should be strictly equal
> ok 437 should be equal
> # line.x(f)(data) passes d, i and data to the specified function f
> ok 438 should be deeply equivalent
> # line.y(f)(data) passes d, i and data to the specified function f
> ok 439 should be deeply equivalent
> # line.defined(f)(data) passes d, i and data to the specified function f
> ok 440 should be deeply equivalent
> # line.x(x)(data) observes the specified function
> ok 441 should be equal
> # line.x(x)(data) observes the specified constant
> ok 442 should be equal
> # line.y(y)(data) observes the specified function
> ok 443 should be equal
> # line.y(y)(data) observes the specified constant
> ok 444 should be equal
> # line.curve(curve) sets the curve method
> ok 445 should be strictly equal
> ok 446 should be equal
> # lineRadial() returns a default radial line shape
> ok 447 should be strictly equal
> ok 448 should be strictly equal
> ok 449 should be strictly equal
> ok 450 should be strictly equal
> ok 451 should be strictly equal
> ok 452 should be equal
> # stackOffsetDiverging(series, order) applies a zero baseline, ignoring
> existing offsets
> ok 453 should be deeply equivalent
> # stackOffsetDiverging(series, order) handles a single series
> ok 454 should be deeply equivalent
> # stackOffsetDiverging(series, order) treats NaN as zero
> ok 455 should be truthy
> ok 456 should be deeply equivalent
> # stackOffsetDiverging(series, order) observes the specified order
> ok 457 should be deeply equivalent
> # stackOffsetDiverging(series, order) puts negative values below zero, in
> order
> ok 458 should be deeply equivalent
> # stackOffsetDiverging(series, order) puts zero values at zero, in order
> ok 459 should be deeply equivalent
> # stackOffsetExpand(series, order) expands to fill [0, 1]
> ok 460 should be deeply equivalent
> # stackOffsetExpand(series, order) treats NaN as zero
> ok 461 should be truthy
> ok 462 should be deeply equivalent
> # stackOffsetExpand(series, order) observes the specified order
> ok 463 should be deeply equivalent
> # stackOffsetNone(series, order) stacks upon the first layer’s existing
> positions
> ok 464 should be deeply equivalent
> # stackOffsetNone(series, order) treats NaN as zero
> ok 465 should be truthy
> ok 466 should be deeply equivalent
> # stackOffsetNone(series, order) observes the specified order
> ok 467 should be deeply equivalent
> # stackOffsetSilhouette(series, order) centers the stack around zero
> ok 468 should be deeply equivalent
> # stackOffsetSilhouette(series, order) treats NaN as zero
> ok 469 should be truthy
> ok 470 should be deeply equivalent
> # stackOffsetSilhouette(series, order) observes the specified order
> ok 471 should be deeply equivalent
> # stackOffsetWiggle(series, order) minimizes weighted wiggle
> ok 472 should be deeply equivalent
> # stackOffsetWiggle(series, order) treats NaN as zero
> ok 473 should be truthy
> ok 474 should be truthy
> ok 475 should be truthy
> ok 476 should be deeply equivalent
> # stackOffsetWiggle(series, order) observes the specified order
> ok 477 should be deeply equivalent
> # stackOrderAppearance(series) returns an order by appearance
> ok 478 should be deeply equivalent
> # stackOrderAppearance(series) treats NaN values as zero
> ok 479 should be deeply equivalent
> # stackOrderAscending(series) returns an order by sum
> ok 480 should be deeply equivalent
> # stackOrderAscending(series) treats NaN values as zero
> ok 481 should be deeply equivalent
> # stackOrderDescending(series) returns an order by sum
> ok 482 should be deeply equivalent
> # stackOrderDescending(series) treats NaN values as zero
> ok 483 should be deeply equivalent
> # stackOrderInsideOut(series) returns an order by appearance
> ok 484 should be deeply equivalent
> # stackOrderInsideOut(series) treats NaN values as zero
> ok 485 should be deeply equivalent
> # stackOrderNone(series) returns [0, 1, … series.length - 1]
> ok 486 should be deeply equivalent
> # stackOrderReverse(series) returns [series.length - 1, series.length - 2, …
> 0]
> ok 487 should be deeply equivalent
> # pie() returns a default pie shape
> ok 488 should be strictly equal
> ok 489 should be truthy
> ok 490 should be truthy
> ok 491 should be strictly equal
> ok 492 should be strictly equal
> ok 493 should be strictly equal
> ok 494 should be strictly equal
> ok 495 should be strictly equal
> # pie(data) returns arcs in input order
> ok 496 should be deeply equivalent
> # pie(data) coerces the specified value to a number
> ok 497 should be deeply equivalent
> # pie(data) treats negative values as zero
> ok 498 should be deeply equivalent
> # pie(data) treats NaN values as zero
> ok 499 should be truthy
> ok 500 should be truthy
> ok 501 should be truthy
> ok 502 should be deeply equivalent
> # pie(data) puts everything at the startAngle when the sum is zero
> ok 503 should be deeply equivalent
> ok 504 should be deeply equivalent
> # pie(data) restricts |endAngle - startAngle| to τ
> ok 505 should be deeply equivalent
> ok 506 should be deeply equivalent
> ok 507 should be deeply equivalent
> ok 508 should be deeply equivalent
> # pie.value(value)(data) observes the specified value function
> ok 509 should be deeply equivalent
> # pie.value(f)(data) passes d, i and data to the specified function f
> ok 510 should be deeply equivalent
> # pie().startAngle(f)(…) propagates the context and arguments to the
> specified function f
> ok 511 should be deeply equivalent
> # pie().startAngle(θ)(data) observes the specified start angle
> ok 512 should be deeply equivalent
> # pie().endAngle(θ)(data) observes the specified end angle
> ok 513 should be deeply equivalent
> # pie().padAngle(δ)(data) observes the specified pad angle
> ok 514 should be deeply equivalent
> # pie().endAngle(f)(…) propagates the context and arguments to the specified
> function f
> ok 515 should be deeply equivalent
> # pie().padAngle(f)(…) propagates the context and arguments to the specified
> function f
> ok 516 should be deeply equivalent
> # pie().startAngle(θ₀).endAngle(θ₁).padAngle(δ)(data) restricts the pad angle
> to |θ₁ - θ₀| / data.length
> ok 517 should be deeply equivalent
> not ok 518 should be deeply equivalent
> ---
> operator: deepEqual
> expected: |-
> [ { data: 1, value: 1, index: 2, startAngle: -2.0943951023931953,
> endAngle: -3.141592653589793, padAngle: 1.0471975511965976 }, { data: 2,
> value: 2, index: 1, startAngle: -1.0471975511965976, endAngle:
> -2.0943951023931953, padAngle: 1.0471975511965976 }, { data: 3, value: 3,
> index: 0, startAngle: -0, endAngle: -1.0471975511965976, padAngle:
> 1.0471975511965976 } ]
> actual: |-
> [ { data: 1, index: 2, value: 1, startAngle: -2.0943951023931953,
> endAngle: -3.141592653589793, padAngle: 1.0471975511965976 }, { data: 2,
> index: 1, value: 2, startAngle: -1.0471975511965976, endAngle:
> -2.0943951023931953, padAngle: 1.0471975511965976 }, { data: 3, index: 0,
> value: 3, startAngle: 0, endAngle: -1.0471975511965976, padAngle:
> 1.0471975511965976 } ]
> at: Test.<anonymous> (/<<PKGBUILDDIR>>/test/pie-test.js:168:8)
> stack: |-
> Error: should be deeply equivalent
> at Test.assert [as _assert]
> (/usr/share/nodejs/tape/lib/test.js:311:54)
> at Test.bound [as _assert]
> (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Test.tapeDeepEqual (/usr/share/nodejs/tape/lib/test.js:552:10)
> at Test.bound [as deepEqual]
> (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Test.<anonymous> (/<<PKGBUILDDIR>>/test/pie-test.js:168:8)
> at Test.bound [as _cb] (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Test.run (/usr/share/nodejs/tape/lib/test.js:114:31)
> at Test.bound [as run] (/usr/share/nodejs/tape/lib/test.js:96:32)
> at Immediate.next [as _onImmediate]
> (/usr/share/nodejs/tape/lib/results.js:88:19)
> at processImmediate (internal/timers.js:461:21)
> ...
> # pie.sortValues(f) sorts arcs by value per the specified comparator function
> f
> ok 519 should be deeply equivalent
> ok 520 should be deeply equivalent
> ok 521 should be strictly equal
> # pie.sort(f) sorts arcs by data per the specified comparator function f
> ok 522 should be deeply equivalent
> ok 523 should be deeply equivalent
> ok 524 should be strictly equal
> # stack() has the expected defaults
> ok 525 should be deeply equivalent
> ok 526 should be strictly equal
> ok 527 should be strictly equal
> ok 528 should be strictly equal
> # stack(data) computes the stacked series for the given data
> ok 529 should be deeply equivalent
> # stack.keys(array) sets the array of constant keys
> ok 530 should be deeply equivalent
> # stack.keys(function) sets the key accessor function
> ok 531 should be deeply equivalent
> # stack(data, arguments…) passes the key accessor any additional arguments
> ok 532 should be deeply equivalent
> ok 533 should be strictly equal
> ok 534 should be strictly equal
> # stack.value(number) sets the constant value
> ok 535 should be strictly equal
> # stack.value(function) sets the value accessor function
> ok 536 should be strictly equal
> # stack(data) passes the value accessor datum, key, index and data
> ok 537 should be deeply equivalent
> ok 538 should be deeply equivalent
> # stack(data) coerces the return value of the value accessor to a number
> ok 539 should be deeply equivalent
> # stack.order(null) is equivalent to stack.order(stackOrderNone)
> ok 540 should be strictly equal
> ok 541 should be strictly equal
> # stack.order(function) sets the order function
> ok 542 should be strictly equal
> ok 543 should be deeply equivalent
> # stack.offset(null) is equivalent to stack.offset(stackOffsetNone)
> ok 544 should be strictly equal
> ok 545 should be strictly equal
> # stack.offset(function) sets the offset function
> ok 546 should be strictly equal
> ok 547 should be deeply equivalent
> # symbol() returns a default symbol shape
> ok 548 should be strictly equal
> ok 549 should be strictly equal
> ok 550 should be strictly equal
> ok 551 should be equal
> # symbol().size(f)(…) propagates the context and arguments to the specified
> function
> ok 552 should be deeply equivalent
> # symbol().type(f)(…) propagates the context and arguments to the specified
> function
> ok 553 should be deeply equivalent
> # symbol.size(size) observes the specified size function
> ok 554 should be strictly equal
> ok 555 should be equal
> ok 556 should be equal
> ok 557 should be equal
> ok 558 should be equal
> ok 559 should be equal
> # symbol.size(size) observes the specified size constant
> ok 560 should be strictly equal
> ok 561 should be equal
> ok 562 should be equal
> ok 563 should be equal
> # symbol.type(symbolCircle) generates the expected path
> ok 564 should be equal
> ok 565 should be equal
> # symbol.type(symbolCross) generates a polygon with the specified size
> ok 566 should be in delta
> ok 567 should be in delta
> # symbol.type(symbolCross) generates the expected path
> ok 568 should be equal
> ok 569 should be equal
> # symbol.type(symbolDiamond) generates a polygon with the specified size
> ok 570 should be in delta
> ok 571 should be in delta
> # symbol.type(symbolDiamond) generates the expected path
> ok 572 should be equal
> ok 573 should be equal
> # symbol.type(symbolStar) generates a polygon with the specified size
> ok 574 should be in delta
> ok 575 should be in delta
> # symbol.type(symbolStar) generates the expected path
> ok 576 should be equal
> ok 577 should be equal
> # symbol.type(symbolSquare) generates a polygon with the specified size
> ok 578 should be in delta
> ok 579 should be in delta
> # symbol.type(symbolSquare) generates the expected path
> ok 580 should be equal
> ok 581 should be equal
> ok 582 should be equal
> # symbol.type(symbolTriangle) generates a polygon with the specified size
> ok 583 should be in delta
> ok 584 should be in delta
> # symbol.type(symbolTriangle) generates the expected path
> ok 585 should be equal
> ok 586 should be equal
> # symbol.type(symbolWye) generates a polygon with the specified size
> ok 587 should be in delta
> ok 588 should be in delta
> # symbol.type(symbolWye) generates the expected path
> ok 589 should be equal
> ok 590 should be equal
> # symbols is the array of symbol types
> ok 591 should be deeply equivalent
>
> 1..591
> # tests 591
> # pass 589
> # fail 2
>
> dh_auto_test: error: /bin/sh -ex debian/tests/pkg-js/test returned exit code 1
The full build log is available from:
http://qa-logs.debian.net/2021/10/23/node-d3-shape_1.3.7-2_unstable.log
A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!
If you reassign this bug to another package, please marking it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects
If you fail to reproduce this, please provide a build log and diff it with mine
so that we can identify if something relevant changed in the meantime.
