assert.Equal(t, set.Contains("d"), true)
	assert.Equal(t, set.Contains("e"), false)

	nset := set.CopyAndInsert("z", "c", "a")
	// Should not mutate original set
	assert.Equal(t, set.List(), []string{"a", "b", "d"})
	assert.Equal(t, nset.List(), []string{"a", "b", "c", "d", "z"})

	assert.Equal(t, nset.Contains("a"), true)
	assert.Equal(t, nset.Contains("b"), true)
	assert.Equal(t, nset.Contains("c"), true)

    html = get_swagger_ui_html(openapi_url="/docs", title="title")
    body_content = html.body.decode()
    assert swagger_js_url in body_content
    assert swagger_css_url in body_content
    assert swagger_favicon_url in body_content


def test_strings_in_custom_swagger():
    swagger_js_url = "swagger_fake_file.js"
    swagger_css_url = "swagger_fake_file.css"

	summary, err := provider.Get(ctx, true)
	assert.NoError(err)

	assert.Equal(summary.Node.NodeName, "test-node")
	assert.Equal(summary.Node.StartTime, systemBootTime)
	assert.Equal(summary.Node.CPU, cgroupStatsMap["/"].cs.CPU)
	assert.Equal(summary.Node.Memory, cgroupStatsMap["/"].cs.Memory)
	assert.Equal(summary.Node.Network, cgroupStatsMap["/"].ns)
	assert.Equal(summary.Node.Fs, rootFsStats)

    response = client.get("/counter/")
    assert response.status_code == 200, response.text
    assert response.json() == {"counter": 1}
    response = client.get("/counter/")
    assert response.status_code == 200, response.text
    assert response.json() == {"counter": 2}


def test_sub_counter():
    counter_holder["counter"] = 0
    response = client.get("/sub-counter/")
    assert response.status_code == 200, response.text

	}

	machineInfo, err := p.getMachineInfo()
	assert.NoError(t, err)
	assert.Equal(t, uint64(100), machineInfo.MemoryCapacity)
	hostname, _ := os.Hostname()
	assert.Equal(t, hostname, machineInfo.MachineID)

	// Check if it's an UUID.
	_, err = uuid.Parse(machineInfo.SystemUUID)
	assert.NoError(t, err)

	id, err := strconv.Atoi(machineInfo.BootID)
	assert.NoError(t, err)
	assert.NotZero(t, id)
}

		channel, data, err := wsRead(ws)
		assert.NoError(t, err, "port %d read", port)
		assert.Equal(t, i*2+dataChannel, int(channel), "port %d channel", port)
		assert.Len(t, data, binary.Size(port), "port %d data size", port)
		assert.Equal(t, binary.LittleEndian.Uint16(data), port, "port %d data", port)

		channel, data, err = wsRead(ws)
		assert.NoError(t, err, "port %d read", port)

			},
		},
		Stats: stats,
	}

	assert.Equal(t, len(actualRootInfos), len(infos))
	assert.Equal(t, actualRootInfos["/"].Spec, infos["/"].Spec)
	assert.Equal(t, len(actualRootInfos["/"].Stats), len(infos["/"].Stats))
	assert.Equal(t, actualRootInfos["/"].Stats[0].Cpu, infos["/"].Stats[0].Cpu)
	assert.Equal(t, actualRootInfos["/"].Stats[0].CpuInst, infos["/"].Stats[0].CpuInst)

            data = websocket.receive_text()
            assert data == "Session cookie or query token value is: fakesession"
            data = websocket.receive_text()
            assert data == f"Message text was: {message}, for item ID: foo"
            message = "Message two"
            websocket.send_text(message)
            data = websocket.receive_text()
            assert data == "Session cookie or query token value is: fakesession"

    assert response.status_code == 401, response.text
    assert response.headers["WWW-Authenticate"] == "Basic"
    assert response.json() == {"detail": "Invalid authentication credentials"}


def test_openapi_schema():
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "openapi": "3.1.0",

            assert attributesAsMap['org.gradle.dependency.bundling'] == 'external'
            assert attributesAsMap['org.gradle.docstype'] == 'sources'
            assert attributesAsMap['org.gradle.usage'] == 'java-runtime'
            assert attributesAsMap['org.gradle.status'] == 'release'
            assert attributesAsMap['org.gradle.libraryelements'] == 'jar'
            assert attributesAsMap['artifactType'] == 'jar'
        }
    }
}