Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

bug: Doctest for docs/src/index.md errors locally #29

Closed
Fe-r-oz opened this issue Jun 27, 2024 · 4 comments
Closed

bug: Doctest for docs/src/index.md errors locally #29

Fe-r-oz opened this issue Jun 27, 2024 · 4 comments
Labels
bug Something isn't working

Comments

@Fe-r-oz
Copy link
Contributor

Fe-r-oz commented Jun 27, 2024

Doctest for docs/src/index.md Errors Locally
Doctests for all the other tests passes locally but when testing the entire package via doctest(BraketSimulator), doctest for docs/src/index.md fails. This prevents all the doctests from running locally.

To make sure that error was independent of my local branch, I made a new branch Doctest solely to run doctests on that branch locally and got the same error!

To reproduce

[ Info: Disabling history file for this session
julia> using BraketSimulator

julia> using Documenter

julia> doctest(BraketSimulator)
┌ Warning: Unable to determine HTML(edit_link = ...) from remote HEAD branch, defaulting to "master".
│ Calling `git remote` failed with an exception. Set JULIA_DEBUG=Documenter to see the error.
│ Unless this is due to a configuration error, the relevant variable should be set explicitly.
└ @ Documenter ~/.julia/packages/Documenter/CJeWX/src/utilities/utilities.jl:640
[ Info: SetupBuildDirectory: setting up build directory.
[ Info: Doctest: running doctests.
┌ Error: doctest failure in ~/Desktop/New/qchem/BraketSimulator.jl/docs/src/index.md:38-58
│ 
│ ```jldoctest
│ julia> using Braket, BraketSimulator
│ 
│ julia> n_qubits = 10;
│ 
│ julia> c = Circuit();
│ 
│ julia> H(c, 0);
│ 
│ julia> foreach(q->CNot(c, 0, q), 1:n_qubits-1);
│ 
│ julia> Amplitude(c, [repeat("0", n_qubits), repeat("1", n_qubits)]);
│ 
│ julia> sim = LocalSimulator("braket_sv_v2"); # use the state vector simulator (without noise)
│ 
│ julia> res = result(simulate(sim, ir(c, Val(:JAQCD)), shots=0));
│ 
│ julia> res.values
│ 1-element Vector{Any}:
│  Dict{String, ComplexF64}("0000000000" => 0.7071067811865475 + 0.0im, "1111111111" => 0.7071067811865475 + 0.0im)
│ ```
│ 
│ Subexpression:
│ 
│ res = result(simulate(sim, ir(c, Val(:JAQCD)), shots=0));
│ 
│ Evaluated output:
│ 
│ ERROR: MethodError: no method matching simulate(::StateVectorSimulator{ComplexF64, Vector{ComplexF64}}, ::Braket.IR.Program, ::Int64, ::Int64; inputs::Dict{String, Float64})
│ 
│ Closest candidates are:
│   simulate(::BraketSimulator.AbstractSimulator, ::Braket.IR.Program, ::Int64; shots, kwargs...)
│    @ BraketSimulator ~/Desktop/New/qchem/BraketSimulator.jl/src/BraketSimulator.jl:236
│   simulate(!Matched::LocalSimulator, ::Union{Braket.AbstractProgram, AnalogHamiltonianSimulation, Circuit}, ::Any...; shots, inputs, kwargs...)
│    @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:62
│   simulate(!Matched::LocalSimulator, !Matched::Vector{T}, ::Any...; shots, max_parallel, inputs, kwargs...) where T
│    @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:93
│   ...
│ 
│ Stacktrace:
│  [1] _run_internal(::StateVectorSimulator{ComplexF64, Vector{ComplexF64}}, ::Braket.IR.Program; shots::Int64, inputs::Dict{String, Float64}, kwargs::@Kwargs{})
│    @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:175
│  [2] simulate(::LocalSimulator, ::Braket.IR.Program; shots::Int64, inputs::Dict{String, Float64}, kwargs::@Kwargs{})
│    @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:64
│  [3] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: MethodError: no method matching simulate(::StateVectorSimulator{ComplexF64, Vector{ComplexF64}}, ::Braket.IR.Program, ::Int64, ::Int64; inputs::Dict{String, Float64})                                                                                                                                            
│    
│    Closest candidates are:
│      simulate(::BraketSimulator.AbstractSimulator, ::Braket.IR.Program, ::Int64; shots, kwargs...)
│       @ BraketSimulator ~/Desktop/New/qchem/BraketSimulator.jl/src/BraketSimulator.jl:236
│      simulate(!Matched::LocalSimulator, ::Union{Braket.AbstractProgram, AnalogHamiltonianSimulation, Circuit}, ::Any...; shots, inputs, kwargs...)
│       @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:62
│      simulate(!Matched::LocalSimulator, !Matched::Vector{T}, ::Any...; shots, max_parallel, inputs, kwargs...) where T
│       @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:93
│      ...
│    
│    Stacktrace:
│     [1] _run_internal(::StateVectorSimulator{ComplexF64, Vector{ComplexF64}}, ::Braket.IR.Program; shots::Int64, inputs::Dict{String, Float64}, kwargs::@Kwargs{})                                                                                                                                                          
│       @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:175
│     [2] simulate(::LocalSimulator, ::Braket.IR.Program; shots::Int64, inputs::Dict{String, Float64}, kwargs::@Kwargs{})
│       @ Braket ~/Desktop/New/braket/2/Braket.jl/src/local_simulator.jl:64
│     [3] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/New/qchem/BraketSimulator.jl/docs/src/index.md:38
┌ Error: doctest failure in ~/Desktop/New/qchem/BraketSimulator.jl/docs/src/index.md:38-58
│ 
│ ```jldoctest
│ julia> using Braket, BraketSimulator
│ 
│ julia> n_qubits = 10;
│ 
│ julia> c = Circuit();
│ 
│ julia> H(c, 0);
│ 
│ julia> foreach(q->CNot(c, 0, q), 1:n_qubits-1);
│ 
│ julia> Amplitude(c, [repeat("0", n_qubits), repeat("1", n_qubits)]);
│ 
│ julia> sim = LocalSimulator("braket_sv_v2"); # use the state vector simulator (without noise)
│ 
│ julia> res = result(simulate(sim, ir(c, Val(:JAQCD)), shots=0));
│ 
│ julia> res.values
│ 1-element Vector{Any}:
│  Dict{String, ComplexF64}("0000000000" => 0.7071067811865475 + 0.0im, "1111111111" => 0.7071067811865475 + 0.0im)
│ ```
│ 
│ Subexpression:
│ 
│ res.values
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `res` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 1-element Vector{Any}:
│  Dict{String, ComplexF64}("0000000000" => 0.7071067811865475 + 0.0im, "1111111111" => 0.7071067811865475 + 0.0im)
│ 
│   diff =
│    1-element Vector{Any}:
│     Dict{String, ComplexF64}("0000000000" => 0.7071067811865475 + 0.0im, "1111111111" => 0.7071067811865475 + 0.0im)ERROR: UndefVarError: `res` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/New/qchem/BraketSimulator.jl/docs/src/index.md:38
┌ Error: Doctesting failed
│   exception =
│    `makedocs` encountered a doctest error. Terminating build
│    Stacktrace:
│      [1] error(s::String)
│        @ Base ./error.jl:35
│      [2] runner(::Type{Documenter.Builder.Doctest}, doc::Documenter.Document)
│        @ Documenter ~/.julia/packages/Documenter/CJeWX/src/builder_pipeline.jl:212
│      [3] dispatch(::Type{Documenter.Builder.DocumentPipeline}, x::Documenter.Document)
│        @ Documenter.Selectors ~/.julia/packages/Documenter/CJeWX/src/utilities/Selectors.jl:170
│      [4] #86
│        @ ~/.julia/packages/Documenter/CJeWX/src/makedocs.jl:248 [inlined]
│      [5] withenv(::Documenter.var"#86#88"{Documenter.Document}, ::Pair{String, Nothing}, ::Vararg{Pair{String, Nothing}})
│        @ Base ./env.jl:257
│      [6] #85
│        @ ~/.julia/packages/Documenter/CJeWX/src/makedocs.jl:247 [inlined]
│      [7] cd(f::Documenter.var"#85#87"{Documenter.Document}, dir::String)
│        @ Base.Filesystem ./file.jl:112
│      [8] makedocs(; debug::Bool, format::Documenter.HTMLWriter.HTML, kwargs::@Kwargs{root::String, source::String, sitename::String, doctest::Symbol, modules::Vector{Module}, doctestfilters::Vector{Regex}, remotes::Nothing, plugins::Vector{Documenter.Plugin}})                                                        
│        @ Documenter ~/.julia/packages/Documenter/CJeWX/src/makedocs.jl:247
│      [9] (::Documenter.var"#all_doctests#131"{Bool, Vector{Regex}, Vector{Documenter.Plugin}, Vector{Module}})()
│        @ Documenter ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:82
│     [10] macro expansion
│        @ ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:107 [inlined]
│     [11] macro expansion
│        @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:669 [inlined]
│     [12] macro expansion
│        @ ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:107 [inlined]
│     [13] macro expansion
│        @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:1577 [inlined]
│     [14] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin})
│        @ Documenter ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:107
│     [15] doctest
│        @ ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:66 [inlined]
│     [16] doctest(package::Module; manual::Bool, testset::Nothing, kwargs::@Kwargs{})
│        @ Documenter ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:34
│     [17] doctest(package::Module)
│        @ Documenter ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:20
│     [18] top-level scope
│        @ REPL[26379]:1
│     [19] eval
│        @ ./boot.jl:385 [inlined]
│     [20] eval_user_input(ast::Any, backend::REPL.REPLBackend, mod::Module)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:150
│     [21] repl_backend_loop(backend::REPL.REPLBackend, get_module::Function)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:246
│     [22] start_repl_backend(backend::REPL.REPLBackend, consumer::Any; get_module::Function)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:231
│     [23] run_repl(repl::REPL.AbstractREPL, consumer::Any; backend_on_current_task::Bool, backend::Any)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:389
│     [24] run_repl(repl::REPL.AbstractREPL, consumer::Any)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:375
│     [25] (::Base.var"#1013#1015"{Bool, Bool, Bool})(REPL::Module)
│        @ Base ./client.jl:432
│     [26] #invokelatest#2
│        @ ./essentials.jl:892 [inlined]
│     [27] invokelatest
│        @ ./essentials.jl:889 [inlined]
│     [28] run_main_repl(interactive::Bool, quiet::Bool, banner::Bool, history_file::Bool, color_set::Bool)
│        @ Base ./client.jl:416
│     [29] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:333
│     [30] _start()
│        @ Base ./client.jl:552
└ @ Documenter ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:96
Doctests: BraketSimulator: Test Failed at /home/.julia/packages/Documenter/CJeWX/src/doctest.jl:107
  Expression: all_doctests()

Stacktrace:
 [1] macro expansion
   @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:672 [inlined]
 [2] macro expansion
   @ ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:107 [inlined]
 [3] macro expansion
   @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:1577 [inlined]
 [4] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin})
   @ Documenter ~/.julia/packages/Documenter/CJeWX/src/doctest.jl:107
Test Summary:             | Fail  Total  Time
Doctests: BraketSimulator |    1      1  9.8s
ERROR: Some tests did not pass: 0 passed, 1 failed, 0 errored, 0 broken.

Also, locally, I was getting this error as well which I fixed locally by setting StaticArrays to "=1.9.5"


ERROR: Unsatisfiable requirements detected for package StaticArrays [90137ffa]:
 StaticArrays [90137ffa] log:
 ├─possible versions are: 0.8.0-1.9.5 or uninstalled
 ├─restricted to versions 1.9.5 by Braket [19504a0f], leaving only versions: 1.9.5
 │ └─Braket [19504a0f] log:
 │   ├─possible versions are: 0.9.0 or uninstalled
 │   └─Braket [19504a0f] is fixed to version 0.9.0
 └─restricted to versions 1.9.3 by BraketSimulator [76d27892] — no versions left
   └─BraketSimulator [76d27892] log:
     ├─possible versions are: 0.0.1 or uninstalled
     └─BraketSimulator [76d27892] is fixed to version 0.0.1

Expected behavior
Doctest should pass for docs/src/index.md Errors Locally

System Information
Linux-based Distribution

@Fe-r-oz Fe-r-oz added the bug Something isn't working label Jun 27, 2024
@kshyatt-aws
Copy link
Member

I think this has been resolved - can you retry on latest main?

@Fe-r-oz
Copy link
Contributor Author

Fe-r-oz commented Aug 21, 2024

Sorry for the late reply. I will let you know soon.

@Fe-r-oz
Copy link
Contributor Author

Fe-r-oz commented Aug 21, 2024

It seems this specific doctest has been resolved. But, now, some other new doctests are failing. Please see the output attached. I think for these respective files, using Braket explicitly in doctests will solve these errors.

Also, I can't seem to compile Braket.jl locally if I have to the latest BraketSimulator.jl, so I have to remove Braket.jl for time being to compile the package. Probably, because of version conflict between project.toml s of them respectively.

If the CI-Documention passed for the big PR that introduced these new doctests, then it seems that maybe since I don't have Braket.jl installed due to conflicts, the doctests error is occuring.

   Resolving package versions...
    Updating `~/.julia/environments/v1.10/Project.toml`
  [76d27892] + BraketSimulator v0.0.2 `~/Desktop/check/BraketSimulator.jl`
    Updating `~/.julia/environments/v1.10/Manifest.toml`
  [76d27892] + BraketSimulator v0.0.2 `~/Desktop/check/BraketSimulator.jl`                                                                    

julia> using BraketSimulator
Precompiling BraketSimulator
        Info Given BraketSimulator was explicitly requested, output will be shown live 
┌ Warning: You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator("braket_sv_v2") for a better user experience.
└ @ BraketSimulator ~/Desktop/check/BraketSimulator.jl/src/validation.jl:89
┌ Warning: You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator("braket_sv_v2") for a better user experience.
└ @ BraketSimulator ~/Desktop/check/BraketSimulator.jl/src/validation.jl:89
┌ Warning: You are running a noise-free circuit on the density matrix simulator. Consider running this circuit on the state vector simulator: LocalSimulator("braket_sv_v2") for a better user experience.
└ @ BraketSimulator ~/Desktop/check/BraketSimulator.jl/src/validation.jl:89
  2 dependencies successfully precompiled in 113 seconds. 33 already precompiled.
  1 dependency had output during precompilation:
┌ BraketSimulator
│  [Output was shown above]                                                                                                    
└                                                                                                                              

julia> using Documenter

julia> doctest(BraketSimulator)
┌ Warning: Unable to determine HTML(edit_link = ...) from remote HEAD branch, defaulting to "master".
│ Calling `git remote` failed with an exception. Set JULIA_DEBUG=Documenter to see the error.
│ Unless this is due to a configuration error, the relevant variable should be set explicitly.
└ @ Documenter ~/.julia/packages/Documenter/qoyeC/src/utilities/utilities.jl:640
[ Info: SetupBuildDirectory: setting up build directory.
[ Info: Doctest: running doctests.
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40-51
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubits(c)
│ QubitSet with 2 elements:
│   0
│   1
```
│ 
│ Subexpression:
│ 
│ c = Circuit();
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `Circuit` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `Circuit` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40-51
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubits(c)
│ QubitSet with 2 elements:
│   0
│   1
```
│ 
│ Subexpression:
│ 
│ add_instruction!(c, Instruction(H(), 0));
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `c` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `c` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40-51
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubits(c)
│ QubitSet with 2 elements:
│   0
│   1
```
│ 
│ Subexpression:
│ 
│ add_instruction!(c, Instruction(CNot(), [0, 1]));
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `c` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `c` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40-51
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubits(c)
│ QubitSet with 2 elements:
│   0
│   1
```
│ 
│ Subexpression:
│ 
│ qubits(c)
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `qubits` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ QubitSet with 2 elements:01
│ 
│   diff =
│    QubitSet with 2 elements:01ERROR: UndefVarError: `qubits` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:40
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45-63
│ 
│ ```jldoctest
│ julia> QubitSet(1, Qubit(0))
│ QubitSet with 2 elements:
│   1
│   Qubit(0)

│ julia> QubitSet([2, 1])
│ QubitSet with 2 elements:
│   2
│   1

│ julia> QubitSet()
│ QubitSet()

│ julia> QubitSet(QubitSet(5, 1))
│ QubitSet with 2 elements:
│   5
│   1
```
│ 
│ Subexpression:
│ 
│ QubitSet(1, Qubit(0))
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `Qubit` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ QubitSet with 2 elements:1Qubit(0)
│ 
│   diff =
│    QubitSet with 2 elements:1Qubit(0)ERROR: UndefVarError: `Qubit` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45-63
│ 
│ ```jldoctest
│ julia> QubitSet(1, Qubit(0))
│ QubitSet with 2 elements:
│   1
│   Qubit(0)

│ julia> QubitSet([2, 1])
│ QubitSet with 2 elements:
│   2
│   1

│ julia> QubitSet()
│ QubitSet()

│ julia> QubitSet(QubitSet(5, 1))
│ QubitSet with 2 elements:
│   5
│   1
```
│ 
│ Subexpression:
│ 
│ QubitSet([2, 1])
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `QubitSet` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ QubitSet with 2 elements:21
│ 
│   diff =
│    QubitSet with 2 elements:21ERROR: UndefVarError: `QubitSet` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45-63
│ 
│ ```jldoctest
│ julia> QubitSet(1, Qubit(0))
│ QubitSet with 2 elements:
│   1
│   Qubit(0)

│ julia> QubitSet([2, 1])
│ QubitSet with 2 elements:
│   2
│   1

│ julia> QubitSet()
│ QubitSet()

│ julia> QubitSet(QubitSet(5, 1))
│ QubitSet with 2 elements:
│   5
│   1
```
│ 
│ Subexpression:
│ 
│ QubitSet()
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `QubitSet` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ QubitSet()
│ 
│   diff =QubitSet()ERROR: UndefVarError: `QubitSet` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45-63
│ 
│ ```jldoctest
│ julia> QubitSet(1, Qubit(0))
│ QubitSet with 2 elements:
│   1
│   Qubit(0)

│ julia> QubitSet([2, 1])
│ QubitSet with 2 elements:
│   2
│   1

│ julia> QubitSet()
│ QubitSet()

│ julia> QubitSet(QubitSet(5, 1))
│ QubitSet with 2 elements:
│   5
│   1
```
│ 
│ Subexpression:
│ 
│ QubitSet(QubitSet(5, 1))
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `QubitSet` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ QubitSet with 2 elements:51
│ 
│   diff =
│    QubitSet with 2 elements:51ERROR: UndefVarError: `QubitSet` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:45
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/results.jl:119-125
│ 
│ ```jldoctest
│ julia> α = FreeParameter(:alpha);

│ julia> op = 2.0 * Observables.X() * Observables.X();

│ julia> AdjointGradient(op, [QubitSet(0, 1)], [α]);
```
│ 
│ Subexpression:
│ 
│ α = FreeParameter(:alpha);
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `FreeParameter` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `FreeParameter` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/results.jl:119
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/results.jl:119-125
│ 
│ ```jldoctest
│ julia> α = FreeParameter(:alpha);

│ julia> op = 2.0 * Observables.X() * Observables.X();

│ julia> AdjointGradient(op, [QubitSet(0, 1)], [α]);
```
│ 
│ Subexpression:
│ 
│ op = 2.0 * Observables.X() * Observables.X();
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `Observables` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `Observables` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/results.jl:119
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/results.jl:119-125
│ 
│ ```jldoctest
│ julia> α = FreeParameter(:alpha);

│ julia> op = 2.0 * Observables.X() * Observables.X();

│ julia> AdjointGradient(op, [QubitSet(0, 1)], [α]);
```
│ 
│ Subexpression:
│ 
│ AdjointGradient(op, [QubitSet(0, 1)], [α]);
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `op` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `op` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/results.jl:119
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/results.jl:129-137
│ 
│ ```jldoctest
│ julia> α = FreeParameter(:alpha);

│ julia> op1 = 2.0 * Observables.X() * Observables.X();

│ julia> op2 = -3.0 * Observables.Y() * Observables.Y();

│ julia> AdjointGradient(op1 + op2, [QubitSet(0, 1), QubitSet(0, 2)], [α]);
```
│ 
│ Subexpression:
│ 
│ α = FreeParameter(:alpha);
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `FreeParameter` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `FreeParameter` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/results.jl:129
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/results.jl:129-137
│ 
│ ```jldoctest
│ julia> α = FreeParameter(:alpha);

│ julia> op1 = 2.0 * Observables.X() * Observables.X();

│ julia> op2 = -3.0 * Observables.Y() * Observables.Y();

│ julia> AdjointGradient(op1 + op2, [QubitSet(0, 1), QubitSet(0, 2)], [α]);
```
│ 
│ Subexpression:
│ 
│ op1 = 2.0 * Observables.X() * Observables.X();
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `Observables` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `Observables` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/results.jl:129
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/results.jl:129-137
│ 
│ ```jldoctest
│ julia> α = FreeParameter(:alpha);

│ julia> op1 = 2.0 * Observables.X() * Observables.X();

│ julia> op2 = -3.0 * Observables.Y() * Observables.Y();

│ julia> AdjointGradient(op1 + op2, [QubitSet(0, 1), QubitSet(0, 2)], [α]);
```
│ 
│ Subexpression:
│ 
│ op2 = -3.0 * Observables.Y() * Observables.Y();
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `Observables` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `Observables` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/results.jl:129
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/results.jl:129-137
│ 
│ ```jldoctest
│ julia> α = FreeParameter(:alpha);

│ julia> op1 = 2.0 * Observables.X() * Observables.X();

│ julia> op2 = -3.0 * Observables.Y() * Observables.Y();

│ julia> AdjointGradient(op1 + op2, [QubitSet(0, 1), QubitSet(0, 2)], [α]);
```
│ 
│ Subexpression:
│ 
│ AdjointGradient(op1 + op2, [QubitSet(0, 1), QubitSet(0, 2)], [α]);
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `op1` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `op1` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/results.jl:129
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66-75
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubit_count(c)
│ 2
```
│ 
│ Subexpression:
│ 
│ c = Circuit();
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `Circuit` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `Circuit` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66-75
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubit_count(c)
│ 2
```
│ 
│ Subexpression:
│ 
│ add_instruction!(c, Instruction(H(), 0));
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `c` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `c` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66-75
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubit_count(c)
│ 2
```
│ 
│ Subexpression:
│ 
│ add_instruction!(c, Instruction(CNot(), [0, 1]));
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `c` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `c` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66-75
│ 
│ ```jldoctest
│ julia> c = Circuit();

│ julia> add_instruction!(c, Instruction(H(), 0));

│ julia> add_instruction!(c, Instruction(CNot(), [0, 1]));

│ julia> qubit_count(c)
│ 2
```
│ 
│ Subexpression:
│ 
│ qubit_count(c)
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `qubit_count` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 2
│ 
│   diff =2ERROR: UndefVarError: `qubit_count` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/circuit.jl:66
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/schemas.jl:10-16
│ 
│ ```jldoctest
│ julia> Instruction(H(), 1)
│ Instruction{H}(H(1.0), QubitSet(1))

│ julia> Instruction(CNot(), [1, Qubit(4)])
│ Instruction{CNot}(CNot(1.0), QubitSet(1, 4))
```
│ 
│ Subexpression:
│ 
│ Instruction(H(), 1)
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `H` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ Instruction{H}(H(1.0), QubitSet(1))
│ 
│   diff =Instruction{H}(H(1.0), QubitSet(1))ERROR: UndefVarError: `H` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/schemas.jl:10
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/schemas.jl:10-16
│ 
│ ```jldoctest
│ julia> Instruction(H(), 1)
│ Instruction{H}(H(1.0), QubitSet(1))

│ julia> Instruction(CNot(), [1, Qubit(4)])
│ Instruction{CNot}(CNot(1.0), QubitSet(1, 4))
```
│ 
│ Subexpression:
│ 
│ Instruction(CNot(), [1, Qubit(4)])
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `CNot` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ Instruction{CNot}(CNot(1.0), QubitSet(1, 4))
│ 
│   diff =Instruction{CNot}(CNot(1.0), QubitSet(1, 4))ERROR: UndefVarError: `CNot` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/schemas.jl:10
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:9-15
│ 
│ ```jldoctest
│ julia> q = Qubit(0)
│ Qubit(0)

│ julia> q == 0
│ true
```
│ 
│ Subexpression:
│ 
│ q = Qubit(0)
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `Qubit` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ Qubit(0)
│ 
│   diff =Qubit(0)ERROR: UndefVarError: `Qubit` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:9
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:9-15
│ 
│ ```jldoctest
│ julia> q = Qubit(0)
│ Qubit(0)

│ julia> q == 0
│ true
```
│ 
│ Subexpression:
│ 
│ q == 0
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `q` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ true
│ 
│   diff =
│    trueERROR: UndefVarError: `q` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/qubit_set.jl:9
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/observables.jl:57-60
│ 
│ ```jldoctest
│ julia> ho = BraketSimulator.Observables.HermitianObservable([0 1; 1 0])
│ HermitianObservable((2, 2))
```
│ 
│ Subexpression:
│ 
│ ho = BraketSimulator.Observables.HermitianObservable([0 1; 1 0])
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `BraketSimulator` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ HermitianObservable((2, 2))
│ 
│   diff =HermitianObservable((2, 2))ERROR: UndefVarError: `BraketSimulator` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/observables.jl:57
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/observables.jl:88-96
│ 
│ ```jldoctest
│ julia> BraketSimulator.Observables.TensorProduct(["x", "h"])
│ X @ H

│ julia> ho = BraketSimulator.Observables.HermitianObservable([0 1; 1 0]);

│ julia> BraketSimulator.Observables.TensorProduct([ho, BraketSimulator.Observables.Z()])
│ HermitianObservable((2, 2)) @ Z
```
│ 
│ Subexpression:
│ 
│ BraketSimulator.Observables.TensorProduct(["x", "h"])
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `BraketSimulator` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ X @ H
│ 
│   diff =
│    X ERROR: UndefVarError: `BraketSimulator` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ Hnone:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/observables.jl:88
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/observables.jl:88-96
│ 
│ ```jldoctest
│ julia> BraketSimulator.Observables.TensorProduct(["x", "h"])
│ X @ H

│ julia> ho = BraketSimulator.Observables.HermitianObservable([0 1; 1 0]);

│ julia> BraketSimulator.Observables.TensorProduct([ho, BraketSimulator.Observables.Z()])
│ HermitianObservable((2, 2)) @ Z
```
│ 
│ Subexpression:
│ 
│ ho = BraketSimulator.Observables.HermitianObservable([0 1; 1 0]);
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `BraketSimulator` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `BraketSimulator` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/observables.jl:88
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/observables.jl:88-96
│ 
│ ```jldoctest
│ julia> BraketSimulator.Observables.TensorProduct(["x", "h"])
│ X @ H

│ julia> ho = BraketSimulator.Observables.HermitianObservable([0 1; 1 0]);

│ julia> BraketSimulator.Observables.TensorProduct([ho, BraketSimulator.Observables.Z()])
│ HermitianObservable((2, 2)) @ Z
```
│ 
│ Subexpression:
│ 
│ BraketSimulator.Observables.TensorProduct([ho, BraketSimulator.Observables.Z()])
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `BraketSimulator` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ HermitianObservable((2, 2)) @ Z
│ 
│   diff =HermitianObservable((2, 2)) ERROR: UndefVarError: `BraketSimulator` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ Znone:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/observables.jl:88
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/observables.jl:154-161
│ 
│ ```jldoctest
│ julia> o1 = 2.0 * BraketSimulator.Observables.I() * BraketSimulator.Observables.Z();

│ julia> o2 = 3.0 * BraketSimulator.Observables.X() * BraketSimulator.Observables.X();

│ julia> o = o1 + o2
│ Sum(2.0 * I @ Z, 3.0 * X @ X)
```
│ 
│ Subexpression:
│ 
│ o1 = 2.0 * BraketSimulator.Observables.I() * BraketSimulator.Observables.Z();
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `BraketSimulator` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `BraketSimulator` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/observables.jl:154
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/observables.jl:154-161
│ 
│ ```jldoctest
│ julia> o1 = 2.0 * BraketSimulator.Observables.I() * BraketSimulator.Observables.Z();

│ julia> o2 = 3.0 * BraketSimulator.Observables.X() * BraketSimulator.Observables.X();

│ julia> o = o1 + o2
│ Sum(2.0 * I @ Z, 3.0 * X @ X)
```
│ 
│ Subexpression:
│ 
│ o2 = 3.0 * BraketSimulator.Observables.X() * BraketSimulator.Observables.X();
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `BraketSimulator` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ 
│ 
│   diff =
│    ERROR: UndefVarError: `BraketSimulator` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/observables.jl:154
┌ Error: doctest failure in ~/Desktop/check/BraketSimulator.jl/src/observables.jl:154-161
│ 
│ ```jldoctest
│ julia> o1 = 2.0 * BraketSimulator.Observables.I() * BraketSimulator.Observables.Z();

│ julia> o2 = 3.0 * BraketSimulator.Observables.X() * BraketSimulator.Observables.X();

│ julia> o = o1 + o2
│ Sum(2.0 * I @ Z, 3.0 * X @ X)
```
│ 
│ Subexpression:
│ 
│ o = o1 + o2
│ 
│ Evaluated output:
│ 
│ ERROR: UndefVarError: `o1` not defined
│ Stacktrace:
│  [1] top-level scope
│    @ none:1
│ 
│ Expected output:
│ 
│ Sum(2.0 * I @ Z, 3.0 * X @ X)
│ 
│   diff =Sum(2.0 * I @ Z, 3.0 * X ERROR: UndefVarError: `o1` not defined
│    Stacktrace:
│     [1] top-level scope
│       @ X)none:1
└ @ Documenter ~/Desktop/check/BraketSimulator.jl/src/observables.jl:154
┌ Error: Doctesting failed
│   exception =`makedocs` encountered a doctest error. Terminating build
│    Stacktrace:
│      [1] error(s::String)
│        @ Base ./error.jl:35
│      [2] runner(::Type{Documenter.Builder.Doctest}, doc::Documenter.Document)
│        @ Documenter ~/.julia/packages/Documenter/qoyeC/src/builder_pipeline.jl:212
│      [3] dispatch(::Type{Documenter.Builder.DocumentPipeline}, x::Documenter.Document)
│        @ Documenter.Selectors ~/.julia/packages/Documenter/qoyeC/src/utilities/Selectors.jl:170
│      [4] #86
│        @ ~/.julia/packages/Documenter/qoyeC/src/makedocs.jl:248 [inlined]
│      [5] withenv(::Documenter.var"#86#88"{Documenter.Document}, ::Pair{String, Nothing}, ::Vararg{Pair{String, Nothing}})
│        @ Base ./env.jl:257
│      [6] #85
│        @ ~/.julia/packages/Documenter/qoyeC/src/makedocs.jl:247 [inlined]
│      [7] cd(f::Documenter.var"#85#87"{Documenter.Document}, dir::String)
│        @ Base.Filesystem ./file.jl:112
│      [8] makedocs(; debug::Bool, format::Documenter.HTMLWriter.HTML, kwargs::@Kwargs{root::String, source::String, sitename::String, doctest::Symbol, modules::Vector{Module}, doctestfilters::Vector{Regex}, remotes::Nothing, plugins::Vector{Documenter.Plugin}})                                                                                                                       
│        @ Documenter ~/.julia/packages/Documenter/qoyeC/src/makedocs.jl:247
│      [9] (::Documenter.var"#all_doctests#131"{Bool, Vector{Regex}, Vector{Documenter.Plugin}, Vector{Module}})()
│        @ Documenter ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:82
│     [10] macro expansion
│        @ ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:107 [inlined]
│     [11] macro expansion
│        @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:669 [inlined]
│     [12] macro expansion
│        @ ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:107 [inlined]
│     [13] macro expansion
│        @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:1577 [inlined]
│     [14] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin})
│        @ Documenter ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:107
│     [15] doctest
│        @ ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:66 [inlined]
│     [16] doctest(package::Module; manual::Bool, testset::Nothing, kwargs::@Kwargs{})
│        @ Documenter ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:34
│     [17] doctest(package::Module)
│        @ Documenter ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:20
│     [18] top-level scope
│        @ REPL[5]:1
│     [19] eval
│        @ ./boot.jl:385 [inlined]
│     [20] eval_user_input(ast::Any, backend::REPL.REPLBackend, mod::Module)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:150
│     [21] repl_backend_loop(backend::REPL.REPLBackend, get_module::Function)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:246
│     [22] start_repl_backend(backend::REPL.REPLBackend, consumer::Any; get_module::Function)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:231
│     [23] run_repl(repl::REPL.AbstractREPL, consumer::Any; backend_on_current_task::Bool, backend::Any)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:389
│     [24] run_repl(repl::REPL.AbstractREPL, consumer::Any)
│        @ REPL ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/REPL/src/REPL.jl:375
│     [25] (::Base.var"#1013#1015"{Bool, Bool, Bool})(REPL::Module)
│        @ Base ./client.jl:432
│     [26] #invokelatest#2
│        @ ./essentials.jl:892 [inlined]
│     [27] invokelatest
│        @ ./essentials.jl:889 [inlined]
│     [28] run_main_repl(interactive::Bool, quiet::Bool, banner::Bool, history_file::Bool, color_set::Bool)
│        @ Base ./client.jl:416
│     [29] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:333
│     [30] _start()
│        @ Base ./client.jl:552
└ @ Documenter ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:96
Doctests: BraketSimulator: Test Failed at /home/Transcendence/.julia/packages/Documenter/qoyeC/src/doctest.jl:107
  Expression: all_doctests()

Stacktrace:
 [1] macro expansion
   @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:672 [inlined]
 [2] macro expansion
   @ ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:107 [inlined]
 [3] macro expansion
   @ ~/.julia/juliaup/julia-1.10.4+0.x64.linux.gnu/share/julia/stdlib/v1.10/Test/src/Test.jl:1577 [inlined]
 [4] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin})
   @ Documenter ~/.julia/packages/Documenter/qoyeC/src/doctest.jl:107
Test Summary:             | Fail  Total  Time
Doctests: BraketSimulator |    1      1  4.4s
ERROR: Some tests did not pass: 0 passed, 1 failed, 0 errored, 0 broken.

@kshyatt-aws
Copy link
Member

I think this has been resolved now that the doctests are part of the full test suite?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
bug Something isn't working
Projects
None yet
Development

No branches or pull requests

2 participants