metanorma-iso 1.3.19 → 1.3.20

data/lib/isodoc/iso/base_convert.rb

@@ -19,7 +19,6 @@ module IsoDoc
         title_attr = { class: "IntroTitle" }
         page_break(out)
         out.div **{ class: "Section3", id: f["id"] } do |div|
-          # div.h1 "Introduction", **attr_code(title_attr)
           clause_name(num, @introduction_lbl, div, title_attr)
           f.elements.each do |e|
             if e.name == "patent-notice"
@@ -200,6 +199,48 @@ module IsoDoc
       def table_footnote_reference_format(a)
         a.content = a.content + ")"
       end
+
+      def clause_parse_title(node, div, c1, out)
+        return inline_header_title(out, node, c1) if c1.nil?
+        super
+      end
+
+      def cleanup(docxml)
+        super
+        remove_internal_hyperlinks(docxml)
+        table_th_center(docxml)
+        docxml
+      end
+
+      def remove_internal_hyperlinks(docxml)
+        docxml.xpath("//a[@href]").each do |a|
+          next unless /^#/.match(a[:href])
+          anchor = a[:href].sub(/^#/, "")
+          next if a["epub:type"] == "footnote"
+          next unless @anchors[anchor]
+          next unless @anchors[anchor][:type]
+          next if @anchors[anchor][:type] == "clause"
+          a.replace(a.children)
+        end
+      end
+
+      def table_th_center(docxml)
+        docxml.xpath("//thead//th | //thead//td").each do |th|
+          th["align"] = "center"
+          th["valign"] = "middle"
+        end
+      end
+
+      def hierarchical_formula_names(clause, num)
+      c = IsoDoc::Function::XrefGen::Counter.new
+       clause.xpath(ns(".//formula")).each do |t|
+         next if t["id"].nil? || t["id"].empty?
+         @anchors[t["id"]] =
+           anchor_struct("#{num}#{hiersep}#{c.increment(t).print}", t,
+                         t["inequality"] ? @inequality_lbl : @formula_lbl,
+                         "formula", t["unnumbered"])
+       end
+      end
     end
   end
 end

data/lib/isodoc/iso/html/isodoc.scss

@@ -598,6 +598,10 @@ table.figdl
         margin-right: 0cm;
       }
 
+table.formula_dl {
+	margin-left:20.15pt;
+}
+
 table.MsoISOTable
 	{mso-style-name:"Table ISO";
 	mso-tstyle-rowband-size:0;

data/lib/isodoc/iso/html/style-human.scss

@@ -820,6 +820,13 @@ margin-right: 20%;
 font-size: 0.9em;
 }
 
+dl.formula_dl {
+background-color: #f7f7f7;
+margin-left: 20%;
+margin-right: 20%;
+font-size: 0.9em;
+}
+
 /*
 Keywords
 */

data/lib/isodoc/iso/html/style-iso.scss

@@ -906,6 +906,12 @@ margin-left: 20%;
 margin-right: 20%;
 }
 
+dl.formula_dl {
+background-color: #f7f7f7;
+margin-left: 20%;
+margin-right: 20%;
+}
+
 /*
 Keywords
 */

data/lib/isodoc/iso/html_convert.rb

@@ -44,6 +44,12 @@ module IsoDoc
         a.content = a.content + ")"
       end
 
+      def table_th_center(docxml)
+        docxml.xpath("//thead//th | //thead//td").each do |th|
+          th["style"] += ";text-align:center;vertical-align:middle;"
+        end
+      end
+
       include BaseConvert
     end
   end

data/lib/metanorma/iso/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   module ISO
-    VERSION = "1.3.19".freeze
+    VERSION = "1.3.20".freeze
   end
 end

data/metanorma-iso.gemspec

@@ -42,6 +42,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop", "= 0.54.0"
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "timecop", "~> 0.9"
-  spec.add_development_dependency "metanorma", "~> 0.3.0"
   spec.add_development_dependency "iev", "~> 0.2.0"
 end

data/spec/asciidoctor-iso/cleanup_spec.rb

@@ -744,6 +744,8 @@ RSpec.describe Asciidoctor::ISO do
     
     == Clause 1
     <<ref1>>
+    <<ref1a>>
+    <<ref1b>>
     <<ref2>>
     <<ref3>>
     <<ref4>>
@@ -762,6 +764,8 @@ RSpec.describe Asciidoctor::ISO do
     * [[[ref3,IEC 123]]], _Standard IEC 123_
     * [[[ref5,20]]], _Standard 10_
     * [[[ref1,ISO 123]]], _Standard ISO 123_
+    * [[[ref1a,ISO 123-100]]], _Standard ISO 123_
+    * [[[ref1b,ISO/TS 123-1]]], _Standard ISO 123_
     * [[[ref4,GB 123]]], _Standard GB 123_
     * [[[ref2,ISO/IEC 123]]], _Standard ISO/IEC 123_
     * [[[ref6,(B)]]], _Standard 20_
@@ -781,10 +785,12 @@ RSpec.describe Asciidoctor::ISO do
         <sections><clause id="_" inline-header="false" obligation="normative">
          <title>Clause 1</title>
          <p id="_"><eref type="inline" bibitemid="ref1" citeas="ISO 123"/>
+         <eref type='inline' bibitemid='ref1a' citeas='ISO 123-100'/>
+<eref type='inline' bibitemid='ref1b' citeas='ISO/TS 123-1'/>
        <eref type="inline" bibitemid="ref2" citeas="ISO/IEC 123"/>
        <eref type="inline" bibitemid="ref3" citeas="IEC 123"/>
        <eref type="inline" bibitemid="ref4" citeas="GB 123"/>
-       <eref type="inline" bibitemid="ref5" citeas="[4]"/>
+       <eref type="inline" bibitemid="ref5" citeas="[6]"/>
        <eref type="inline" bibitemid="ref6" citeas="[B]"/>
        <eref type="inline" bibitemid="ref7" citeas="[A]"/>
        <xref target="ref8"/>
@@ -802,24 +808,54 @@ RSpec.describe Asciidoctor::ISO do
              <abbreviation>ISO</abbreviation>
            </organization>
          </contributor>
-       </bibitem><bibitem id="ref2" type="standard">
-         <title format="text/plain">Standard ISO/IEC 123</title>
-         <docidentifier>ISO/IEC 123</docidentifier>
-         <contributor>
-           <role type="publisher"/>
-           <organization>
-             <name>International Organization for Standardization</name>
-             <abbreviation>ISO</abbreviation>
-           </organization>
-         </contributor>
-         <contributor>
-           <role type="publisher"/>
-           <organization>
-             <name>International Electrotechnical Commission</name>
-             <abbreviation>IEC</abbreviation>
-           </organization>
-         </contributor>
-       </bibitem><bibitem id="ref3" type="standard">
+       </bibitem>
+        <bibitem id='ref2' type='standard'>
+                 <title format='text/plain'>Standard ISO/IEC 123</title>
+                 <docidentifier>ISO/IEC 123</docidentifier>
+                 <contributor>
+                   <role type='publisher'/>
+                   <organization>
+                     <name>International Organization for Standardization</name>
+                     <abbreviation>ISO</abbreviation>
+                   </organization>
+                 </contributor>
+                 <contributor>
+                   <role type='publisher'/>
+                   <organization>
+                     <name>International Electrotechnical Commission</name>
+                     <abbreviation>IEC</abbreviation>
+                   </organization>
+                 </contributor>
+               </bibitem>
+       <bibitem id='ref1b' type='standard'>
+  <title format='text/plain'>Standard ISO 123</title>
+  <docidentifier>ISO/TS 123-1</docidentifier>
+  <contributor>
+    <role type='publisher'/>
+    <organization>
+      <name>International Organization for Standardization</name>
+      <abbreviation>ISO</abbreviation>
+    </organization>
+  </contributor>
+  <contributor>
+    <role type='publisher'/>
+    <organization>
+      <name>TS</name>
+    </organization>
+  </contributor>
+</bibitem>
+<bibitem id='ref1a' type='standard'>
+  <title format='text/plain'>Standard ISO 123</title>
+  <docidentifier>ISO 123-100</docidentifier>
+  <contributor>
+    <role type='publisher'/>
+    <organization>
+      <name>International Organization for Standardization</name>
+      <abbreviation>ISO</abbreviation>
+    </organization>
+  </contributor>
+</bibitem>
+       <bibitem id="ref3" type="standard">
          <title format="text/plain">Standard IEC 123</title>
          <docidentifier>IEC 123</docidentifier>
          <contributor>
@@ -833,7 +869,7 @@ RSpec.describe Asciidoctor::ISO do
          <formattedref format="application/x-isodoc+xml">
            <em>Standard 10</em>
          </formattedref>
-         <docidentifier type="metanorma">[4]</docidentifier>
+         <docidentifier type="metanorma">[6]</docidentifier>
        </bibitem><bibitem id="ref4">
          <formattedref format="application/x-isodoc+xml">
            <em>Standard GB 123</em>
@@ -900,7 +936,7 @@ RSpec.describe Asciidoctor::ISO do
          <formattedref format="application/x-isodoc+xml">
            <em>Standard 10</em>
          </formattedref>
-         <docidentifier type="metanorma">[11]</docidentifier>
+         <docidentifier type="metanorma">[13]</docidentifier>
        </bibitem><bibitem id="ref14">
          <formattedref format="application/x-isodoc+xml">
            <em>Standard GB 123</em>

data/spec/asciidoctor-iso/validate_spec.rb

@@ -4,7 +4,8 @@ require "fileutils"
 RSpec.describe Asciidoctor::ISO do
 
 it "Warns of illegal doctype" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/pizza is not a recognised document type/).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -14,10 +15,12 @@ it "Warns of illegal doctype" do
 
   text
   INPUT
+    expect(File.read("test.err")).to include "pizza is not a recognised document type"
 end
 
 it "Warns of illegal script" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/pizza is not a recognised script/).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -27,10 +30,12 @@ it "Warns of illegal script" do
 
   text
   INPUT
+    expect(File.read("test.err")).to include "pizza is not a recognised script"
 end
 
 it "Warns of illegal stage" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/pizza is not a recognised stage/).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -40,10 +45,12 @@ it "Warns of illegal stage" do
 
   text
   INPUT
+    expect(File.read("test.err")).to include "pizza is not a recognised stage"
 end
 
 it "Warns of illegal substage" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/pizza is not a recognised substage/).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -54,10 +61,12 @@ it "Warns of illegal substage" do
 
   text
   INPUT
+    expect(File.read("test.err")).to include "pizza is not a recognised substage"
 end
 
 it "Warns of illegal iteration" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/pizza is not a recognised iteration/).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -68,10 +77,12 @@ it "Warns of illegal iteration" do
 
   text
   INPUT
+    expect(File.read("test.err")).to include "pizza is not a recognised iteration"
 end
 
 it "Warns of illegal script" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/pizza is not a recognised script/).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -81,49 +92,59 @@ it "Warns of illegal script" do
 
   text
   INPUT
+    expect(File.read("test.err")).to include "pizza is not a recognised script"
 end
 
 
 it "warns that introduction may contain requirement" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Introduction may contain requirement/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   == Introduction
 
   The widget is required not to be larger than 15 cm.
   INPUT
+    expect(File.read("test.err")).to include "Introduction may contain requirement"
 end
 
 it "warns that foreword may contain recommendation" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Foreword may contain recommendation/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   It is not recommended that widgets should be larger than 15 cm.
 
   == Clause
   INPUT
+    expect(File.read("test.err")).to include "Foreword may contain recommendation"
 end
 
 it "warns that foreword may contain permission" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Foreword may contain permission/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   No widget is required to be larger than 15 cm.
 
   == Clause
   INPUT
+    expect(File.read("test.err")).to include "Foreword may contain permission"
 end
 
 it "warns that scope may contain recommendation" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Scope may contain recommendation/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Scope
   It is not recommended that widgets should be larger than 15 cm.
   INPUT
+    expect(File.read("test.err")).to include "Scope may contain recommendation"
 end
 
 it "warns that definition may contain requirement" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Definition may contain requirement/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Terms and Definitions
@@ -133,10 +154,12 @@ it "warns that definition may contain requirement" do
   It is required that there is a definition.
 
   INPUT
+    expect(File.read("test.err")).to include "Definition may contain requirement"
 end
 
 it "warns that term example may contain recommendation" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Example may contain recommendation/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Terms and Definitions
@@ -146,43 +169,53 @@ it "warns that term example may contain recommendation" do
   [example]
   It is not recommended that widgets should be larger than 15 cm.
   INPUT
+    expect(File.read("test.err")).to include "Example may contain recommendation"
 end
 
 it "warns that note may contain recommendation" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Note may contain recommendation/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   NOTE: It is not recommended that widgets should be larger than 15 cm.
   INPUT
+    expect(File.read("test.err")).to include "Note may contain recommendation"
 end
 
 it "warns that footnote may contain recommendation" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Footnote may contain recommendation/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   footnote:[It is not recommended that widgets should be larger than 15 cm.]
   INPUT
+    expect(File.read("test.err")).to include "Footnote may contain recommendation"
 end
 
 it "warns that term source is not in expected format" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/term reference not in expected format/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   [.source]
   I am a generic paragraph
   INPUT
+    expect(File.read("test.err")).to include "term reference not in expected format"
 end
 
 it "warns that figure does not have title" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/Figure should have title/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   image::spec/examples/rice_images/rice_image1.png[]
   INPUT
+    expect(File.read("test.err")).to include "Figure should have title"
 end
 
 it "warns that callouts do not match annotations" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/mismatch of callouts and annotations/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
       #{VALIDATING_BLANK_HDR}
       [source,ruby]
       --
@@ -194,19 +227,23 @@ it "warns that callouts do not match annotations" do
       <1> This is one callout
       <2> This is another callout
       INPUT
+    expect(File.read("test.err")).to include "mismatch of callouts and annotations"
 end
 
 it "warns that term source is not a real reference" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/iso123 is not a real reference/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   [.source]
   <<iso123>>
   INPUT
+    expect(File.read("test.err")).to include "iso123 is not a real reference"
 end
 
 it "warns that undated reference has locality" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/undated reference ISO 123 should not contain specific elements/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   
   == Scope
@@ -216,10 +253,12 @@ it "warns that undated reference has locality" do
   == Normative References
   * [[[iso123,ISO 123]]] _Standard_
   INPUT
+    expect(File.read("test.err")).to include "undated reference ISO 123 should not contain specific elements"
 end
 
 it "do not warn that undated reference which is a bibliographic reference has locality" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.not_to output(/undated reference \[1\] should not contain specific elements/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Scope
@@ -229,10 +268,12 @@ it "do not warn that undated reference which is a bibliographic reference has lo
   == Bibliography
   * [[[iso123,1]]] _Standard_
   INPUT
+    expect(File.read("test.err")).not_to include "undated reference [1] should not contain specific elements"
 end
 
 it "do not warn that undated IEV reference has locality" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.not_to output(/undated reference IEV should not contain specific elements/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Scope
@@ -242,10 +283,12 @@ it "do not warn that undated IEV reference has locality" do
   == Normative References
   * [[[iev,IEV]]] _Standard_
   INPUT
+    expect(File.read("test.err")).not_to include "undated reference IEV should not contain specific elements"
 end
 
 it "do not warn that in print has locality" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.not_to output(/undated reference ISO 123 should not contain specific elements/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Scope
@@ -255,154 +298,187 @@ it "do not warn that in print has locality" do
   == Normative References
   * [[[iev,ISO 123:--]]] _Standard_
   INPUT
+    expect(File.read("test.err")).not_to include "undated reference ISO 123 should not contain specific elements"
 end
 
 it "warns of Non-reference in bibliography" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(/no anchor on reference/).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Normative References
   * I am not a reference
   INPUT
+    expect(File.read("test.err")).to include "no anchor on reference"
 end
 
 it "warns of Non-ISO reference in Normative References" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{non-ISO/IEC reference not expected as normative}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   [bibliography]
   == Normative References
   * [[[XYZ,IESO 121]]] _Standard_
   INPUT
+    expect(File.read("test.err")).to include "non-ISO/IEC reference not expected as normative"
 end
 
 it "warns that Scope contains subclauses" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Scope contains subclauses: should be succinct}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Scope
   
   === Scope subclause
   INPUT
+    expect(File.read("test.err")).to include "Scope contains subclauses: should be succinct"
 end
 
 
 it "warns that Table should have title" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Table should have title}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}     
 
   |===
   |a |b |c
   |===
   INPUT
+    expect(File.read("test.err")).to include "Table should have title"
 end
 
 it "gives Style warning if number not broken up in threes" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{number not broken up in threes}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}     
 
   == Clause
   12121
   INPUT
+    expect(File.read("test.err")).to include "number not broken up in threes"
 end
 
 it "gives No style warning if number not broken up in threes is ISO reference" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to_not output(%r{number not broken up in threes}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}     
 
   == Clause
   ISO 12121
   INPUT
+    expect(File.read("test.err")).not_to include "number not broken up in threes"
 end
 
 it "Style warning if decimal point" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{possible decimal point}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}     
 
   == Clause
   8.1
   INPUT
+    expect(File.read("test.err")).to include "possible decimal point"
 end
 
 it "Style warning if billion used" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{ambiguous number}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}     
 
   == Clause
   "Billions" are a term of art.
   INPUT
+    expect(File.read("test.err")).to include "ambiguous number"
 end
 
 it "Style warning if no space before percent sign" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{no space before percent sign}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}     
 
   == Clause
   95%
   INPUT
+    expect(File.read("test.err")).to include "no space before percent sign"
 end
 
 it "Style warning if unbracketed tolerance before percent sign" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{unbracketed tolerance before percent sign}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Clause
   95 ± 5 %
   INPUT
+    expect(File.read("test.err")).to include "unbracketed tolerance before percent sign"
 end
 
 it "Style warning if dots in abbreviation" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{no dots in abbreviation}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Clause
   r.p.m.
   INPUT
+    expect(File.read("test.err")).to include "no dots in abbreviation"
 end
 
 it "No Style warning if dots in abbreviation are e.g." do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to_not output(%r{no dots in abbreviation}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Clause
   e.g. 5
   INPUT
+    expect(File.read("test.err")).not_to include "no dots in abbreviation"
 end
 
 it "Style warning if ppm used" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{language-specific abbreviation}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Clause
   5 ppm
   INPUT
+    expect(File.read("test.err")).to include "language-specific abbreviation"
 end
 
 it "Style warning if space between number and degree" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{space between number and degrees/minutes/seconds}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Clause
   5 °
   INPUT
+    expect(File.read("test.err")).to include "space between number and degrees/minutes/seconds"
 end
 
 it "Style warning if no space between number and SI unit" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{no space between number and SI unit}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Clause
   A measurement of 5Bq was taken.
   INPUT
+    expect(File.read("test.err")).to include "no space between number and SI unit"
 end
 
 it "Style warning if mins used" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{non-standard unit}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Clause
   5 mins
   INPUT
+    expect(File.read("test.err")).to include "non-standard unit"
 end
 
 # can't test: our asciidoc template won't allow this to be generated
@@ -426,7 +502,8 @@ end
 #end
 
 it "Style warning if two Symbols and Abbreviated Terms sections" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{only one Symbols and Abbreviated Terms section in the standard}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Terms and Abbreviations
@@ -435,30 +512,36 @@ it "Style warning if two Symbols and Abbreviated Terms sections" do
 
   == Symbols and Abbreviated Terms
   INPUT
+    expect(File.read("test.err")).to include "Only one Symbols and Abbreviated Terms section in the standard"
 end
 
 it "Style warning if Symbols and Abbreviated Terms contains extraneous matter" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Symbols and Abbreviated Terms can only contain a definition list}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Symbols and Abbreviated Terms
 
   Paragraph
   INPUT
+    expect(File.read("test.err")).to include "Symbols and Abbreviated Terms can only contain a definition list"
 end
 
 it "Warning if do not start with scope or introduction" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Prefatory material must be followed by \(clause\) Scope}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   == Symbols and Abbreviated Terms
 
   Paragraph
   INPUT
+    expect(File.read("test.err")).to include "Prefatory material must be followed by (clause) Scope"
 end
 
 it "Warning if introduction not followed by scope" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Prefatory material must be followed by \(clause\) Scope}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword 
@@ -470,10 +553,12 @@ it "Warning if introduction not followed by scope" do
 
   Paragraph
   INPUT
+    expect(File.read("test.err")).to include "Prefatory material must be followed by (clause) Scope"
 end
 
 it "Warning if normative references not followed by terms and definitions" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Normative References must be followed by Terms and Definitions}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword 
@@ -488,10 +573,12 @@ it "Warning if normative references not followed by terms and definitions" do
 
   Paragraph
   INPUT
+    expect(File.read("test.err")).to include "Normative References must be followed by Terms and Definitions"
 end
 
 it "Warning if there are no clauses in the document" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Document must contain clause after Terms and Definitions}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword 
@@ -507,10 +594,12 @@ it "Warning if there are no clauses in the document" do
   == Symbols and Abbreviated Terms
 
   INPUT
+    expect(File.read("test.err")).to include "Document must contain clause after Terms and Definitions"
 end
 
 it "Warning if scope occurs after Terms and Definitions" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Scope must occur before Terms and Definitions}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword
@@ -526,10 +615,12 @@ it "Warning if scope occurs after Terms and Definitions" do
   == Scope
 
   INPUT
+    expect(File.read("test.err")).to include "Scope must occur before Terms and Definitions"
 end
 
 it "Warning if scope occurs after Terms and Definitions" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Scope must occur before Terms and Definitions}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword
@@ -547,10 +638,12 @@ it "Warning if scope occurs after Terms and Definitions" do
   == Scope
 
   INPUT
+    expect(File.read("test.err")).to include "Scope must occur before Terms and Definitions"
 end
 
 it "Warning if Symbols and Abbreviated Terms does not occur immediately after Terms and Definitions" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Only annexes and references can follow clauses}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword
@@ -568,10 +661,12 @@ it "Warning if Symbols and Abbreviated Terms does not occur immediately after Te
   == Symbols and Abbreviated Terms
 
   INPUT
+    expect(File.read("test.err")).to include "Only annexes and references can follow clauses"
 end
 
 it "Warning if no normative references" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Document must include \(references\) Normative References}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword
@@ -593,10 +688,12 @@ it "Warning if no normative references" do
   == Appendix C
 
   INPUT
+    expect(File.read("test.err")).to include "Document must include (references) Normative References"
 end
 
 it "Warning if final section is not named Bibliography" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{There are sections after the final Bibliography}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword
@@ -624,10 +721,12 @@ it "Warning if final section is not named Bibliography" do
   == Appendix C
 
   INPUT
+    expect(File.read("test.err")).to include "There are sections after the final Bibliography"
 end
 
 it "Warning if final section is not styled Bibliography" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Section not marked up as \[bibliography\]!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   .Foreword
@@ -651,10 +750,12 @@ it "Warning if final section is not styled Bibliography" do
   == Bibliography
 
   INPUT
+    expect(File.read("test.err")).to include "Section not marked up as [bibliography]"
 end
 
 it "Warning if English title intro and no French title intro" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{No French Title Intro!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -663,10 +764,12 @@ it "Warning if English title intro and no French title intro" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "No French Title Intro"
 end
 
 it "Warning if French title intro and no English title intro" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{No English Title Intro!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -675,11 +778,13 @@ it "Warning if French title intro and no English title intro" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "No English Title Intro"
 end
 
 
 it "Warning if English title and no French intro" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{No French Title!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -688,10 +793,12 @@ it "Warning if English title and no French intro" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "No French Title"
 end
 
 it "Warning if French title and no English title" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{No English Title!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -700,10 +807,12 @@ it "Warning if French title and no English title" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "No English Title"
 end
 
 it "Warning if English title part and no French title part" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{No French Title Part!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -712,10 +821,12 @@ it "Warning if English title part and no French title part" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "No French Title Part"
 end
 
 it "Warning if French title part and no English title part" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{No English Title Part!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -724,10 +835,12 @@ it "Warning if French title part and no English title part" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "No English Title Part"
 end
 
 it "Warning if non-IEC document with subpart" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Subpart defined on non-IEC document!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -738,10 +851,12 @@ it "Warning if non-IEC document with subpart" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "Subpart defined on non-IEC document"
 end
 
 it "No warning if joint IEC/non-IEC document with subpart" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.not_to output(%r{Subpart defined on non-IEC document!}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -752,10 +867,12 @@ it "No warning if joint IEC/non-IEC document with subpart" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).not_to include "Subpart defined on non-IEC document"
 end
 
 it "Warning if main title contains document type" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Main Title may name document type}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -764,10 +881,12 @@ it "Warning if main title contains document type" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "Main Title may name document type"
 end
 
 it "Warning if intro title contains document type" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Title Intro may name document type}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -776,19 +895,23 @@ it "Warning if intro title contains document type" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "Title Intro may name document type"
 end
 
 it "Each first-level subclause must have a title" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{each first-level subclause must have a title}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   == Clause
 
   === {blank}
   INPUT
+    expect(File.read("test.err")).to include "each first-level subclause must have a title"
 end
 
 it "All subclauses must have a title, or none" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{all subclauses must have a title, or none}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   == Clause
 
@@ -798,20 +921,24 @@ it "All subclauses must have a title, or none" do
 
   ==== Subsubclause
   INPUT
+    expect(File.read("test.err")).to include "all subclauses must have a title, or none"
 end
 
 it "Warning if subclause is only child of its parent, or none" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{subclause is only child}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   == Clause
 
   === Subclause
 
   INPUT
+    expect(File.read("test.err")).to include "subclause is only child"
 end
 
 it "Warning if invalid technical committee type" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{invalid technical committee type}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -820,10 +947,12 @@ it "Warning if invalid technical committee type" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "invalid technical committee type"
 end
 
 it "Warning if invalid subcommittee type" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{invalid subcommittee type}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -832,10 +961,12 @@ it "Warning if invalid subcommittee type" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "invalid subcommittee type"
 end
 
 it "Warning if invalid subcommittee type" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{invalid subcommittee type}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -844,10 +975,12 @@ it "Warning if invalid subcommittee type" do
   :no-isobib:
 
   INPUT
+    expect(File.read("test.err")).to include "invalid subcommittee type"
 end
 
 it "Warning if 'see' crossreference points to normative section" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{'see terms' is pointing to a normative section}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   [[terms]]
   == Terms and Definitions
@@ -855,10 +988,12 @@ it "Warning if 'see' crossreference points to normative section" do
   == Clause
   See <<terms>>
   INPUT
+    expect(File.read("test.err")).to include "'see terms' is pointing to a normative section"
 end
 
 it "Warning if 'see' reference points to normative reference" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{is pointing to a normative reference}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   [bibliography]
   == Normative References
@@ -867,10 +1002,12 @@ it "Warning if 'see' reference points to normative reference" do
   == Clause
   See <<terms>>
   INPUT
+    expect(File.read("test.err")).to include "is pointing to a normative reference"
 end
 
 it "Warning if term definition starts with article" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{term definition starts with article}).to_stderr 
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   == Terms and Definitions
   
@@ -878,10 +1015,12 @@ it "Warning if term definition starts with article" do
 
   The definition of a term is a part of the specialized vocabulary of a particular field
   INPUT
+    expect(File.read("test.err")).to include "term definition starts with article"
 end
 
 it "Warning if term definition ends with period" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{term definition ends with period}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   == Terms and Definitions
   
@@ -889,19 +1028,23 @@ it "Warning if term definition ends with period" do
 
   Part of the specialized vocabulary of a particular field.
   INPUT
+    expect(File.read("test.err")).to include "term definition ends with period"
 end
 
 it "validates document against ISO XML schema" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{value of attribute "align" is invalid; must be equal to}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
 
   [align=mid-air]
   Para
   INPUT
+    expect(File.read("test.err")).to include 'value of attribute "align" is invalid; must be equal to'
 end
 
 it "Warn if more than 7 levels of subclause" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Exceeds the maximum clause depth of 7}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -929,10 +1072,12 @@ it "Warn if more than 7 levels of subclause" do
   ====== Clause
 
   INPUT
+    expect(File.read("test.err")).to include "Exceeds the maximum clause depth of 7"
 end
 
 it "Do not warn if not more than 7 levels of subclause" do
-  expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.not_to output(%r{exceeds the maximum clause depth of 7}).to_stderr
+    FileUtils.rm_f "test.err"
+  Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   = Document title
   Author
   :docfile: test.adoc
@@ -957,10 +1102,12 @@ it "Do not warn if not more than 7 levels of subclause" do
   ====== Clause
 
   INPUT
+    expect(File.read("test.err")).not_to include "exceeds the maximum clause depth of 7"
 end
 
 it "Warn if term citation in Terms & Definitions not preceded with italicised term" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{term citation not preceded with italicised term}).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   == Terms and Definitions
 
@@ -969,16 +1116,19 @@ it "Warn if term citation in Terms & Definitions not preceded with italicised te
 
   The definition of a term (<<term>>) is a part of the specialized vocabulary of a particular field
   INPUT
+    expect(File.read("test.err")).to include "term citation not preceded with italicised term"
 end
 
 it "Warn if an undated reference has no associated footnote" do
-    expect { Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true) }.to output(%r{Reference ISO8 does not have an associated footnote indicating unpublished status}).to_stderr
+    FileUtils.rm_f "test.err"
+    Asciidoctor.convert(<<~"INPUT", backend: :iso, header_footer: true)
   #{VALIDATING_BLANK_HDR}
   
   [bibliography]
   == Bibliography
   * [[[ISO8,ISO 8:--]]], _Title_
   INPUT
+    expect(File.read("test.err")).to include "Reference ISO8 does not have an associated footnote indicating unpublished status"
 end