tree 8ceb9d19cd7e6b7b43d5c2281fdd90bf7f848f62
parent 473bd872fc0ccce52f2050ac2bbbb2053069afe7
author Ben Clayton <bclayton@google.com> 1580333975 +0000
committer GitHub <noreply@github.com> 1580333975 -0500
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJeMfuXCRBK7hj4Ov3rIwAAdHIIABFVpOz1w4uGwTnFhsLHk0Ci
 vI1pOU2XC5eqNhdDwYcx2z8jXitmz0wnEB7FDpkPmeNvh5unFNrIFlId6jz3lVBc
 Y1jgW1opxL0kbFqtwW1+uOzlDI/GiyAjERK7xNBu5jMrIPJAxtd2G4LBcHkhXRZK
 eNpDz83NdrJ1DHnLy7QLA0BwmWN4PDZrEGtEZe5eYO8XsjEgKNHUNTmoOcMqc6t1
 0+fQNWEYS762pxJH6Laj7Aw0kkWVaaBXHkZnu5Ak+TLMvMW1xfL+d534zG3vdO3S
 4g1Rid1Hq9OSmGI0qt1bJybhnNhn0mM1xMvnzUMB20IzeMXbuG0y1eCjllqMX2I=
 =bXdz
 -----END PGP SIGNATURE-----
 

Result: Support composite results (#775)

This change adds the `+=` operator to `amber::Result`, allowing results to contain more than one error message.
This simplifies the accumulation of errors produced by concurrent testing.

Also make `Result::Error()` return `"<no error message given>"` if a `Result` is constructed with an empty string.

Added tests.