Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! e>4 4 CreateTagFromArrayTests.phpnu [ "foo:bar",
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespace()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributes()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContent()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndAttributesAndContent()
{
$original = array(
"qname" => "foo:bar",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndContent()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithEntitiesNone()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_ENTITIES_NONE));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntities()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineFalse()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = false;
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrue()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$expected =
<<< EOF
I'm inside the tag
EOF;
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndent()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$expected =
<<< EOF
I'm inside the tag
EOF;
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$linebreak = "^";
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = true;
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = false;
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithInvalidArray()
{
$badArray = array(
"foo" => "bar",
);
$expectedError = "You must either supply a qualified name (qname) or local tag name (localPart).";
$this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithNamespaceAndAttributesAndContentButWithoutQname()
{
$original = array(
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expectedError = "You must either supply a qualified name (qname) or local tag name (localPart).";
$this->assertEquals($expectedError, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithNonScalarContent()
{
$badArray = array(
'content' => array('foo', 'bar'),
);
$expectedError = "Supplied non-scalar value as tag content";
$this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithArrayOfNamespaces()
{
$original = array(
'qname' => 'foo:bar',
'namespaces' => array('ns1' => 'uri1', 'ns2' => 'uri2'),
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameDerivedFromNamespaceUriAndLocalPart()
{
$original = array(
'namespaceUri' => 'http://bar.org',
'localPart' => 'foo'
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameDerivedFromNamespaceAndLocalPart()
{
$original = array(
'namespace' => 'http://foo.org',
'localPart' => 'bar'
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameDerivedFromLocalPart()
{
$original = array(
'namespace' => '',
'localPart' => 'bar'
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithImplicitlyEmptyContentAndCollapseNoneDoesNotCollapseTag()
{
$original = array('qname' => 'tag1');
$expected = "";
$actual = XML_Util::createTagFromArray(
$original,
XML_UTIL_REPLACE_ENTITIES, // default $replaceEntities
false, // default $multiline
'_auto', // default $indent
"\n", // default $linebreak
true, // default $sortAttributes
XML_UTIL_COLLAPSE_NONE
);
$this->assertEquals($expected, $actual);
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayForCdataWithExplicitlyEmptyContentDoesNotCollapseTag()
{
$original = array('qname' => 'tag1', 'content' => '');
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_CDATA_SECTION));
}
}
PK ! C ReplaceEntitiesTests.phpnu [ .';
}
protected function getUtf8Data()
{
return 'This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê';
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleData()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData()));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), 'INVALID_OPTION'));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForUtf8DataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequired()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesHtml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForUtf8DataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding));
}
}
PK ! یu ApiVersionTests.phpnu [ assertEquals('1.4', XML_Util::apiVersion());
}
}PK ! Gs Bug5392Tests.phpnu [ , & and " as well as ä, ö, ß, à and ê';
$replacedResult = XML_Util::replaceEntities($original, XML_UTIL_ENTITIES_HTML, "UTF-8");
$reversedResult = XML_Util::reverseEntities($replacedResult, XML_UTIL_ENTITIES_HTML, "UTF-8");
$this->assertEquals($original, $reversedResult, "Failed bugcheck.");
}
}
PK ! 4ej j CreateCDataSectionTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createCDataSection($original));
}
}
PK ! |\5 CollapseEmptyTagsTests.phpnu [ ";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsBasicUsageAlongsideNonemptyTag()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseAll()
{
$emptyTag = "";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagAlongsideEmptyTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyPrefixedTagAlongsideNonemptyTagAlongsideEmptyPrefixedTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyNsPrefixedTagAlongsideNonemptyTagAlongsideEmptyNsPrefixedTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseXhtml()
{
$emptyTag = "";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_XHTML_ONLY));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseXhtml()
{
$emptyTag = "";
$otherTag = "baz";
$xhtmlTag = "
";
$expected = "
baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $xhtmlTag . $otherTag, XML_UTIL_COLLAPSE_XHTML_ONLY));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseNone()
{
$emptyTag = "";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_NONE));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseNone()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_NONE));
}
}
PK ! G G SplitQualifiedNameTests.phpnu [ 'xslt',
'localPart' => 'stylesheet',
);
$this->assertEquals($expected, XML_Util::splitQualifiedName($original));
}
/**
* @covers XML_Util::splitQualifiedName()
*/
public function testSplitQualifiedNameWithNamespace()
{
$original = "stylesheet";
$namespace = "myNs";
$expected = array(
'namespace' => 'myNs',
'localPart' => 'stylesheet',
);
$this->assertEquals($expected, XML_Util::splitQualifiedName($original, $namespace));
}
}
PK ! Yq Bug21184Tests.phpnu [ one';
$this->assertEquals($xml, XML_Util::collapseEmptyTags($xml, XML_UTIL_COLLAPSE_ALL));
}
}
PK ! >M Bug4950Tests.phpnu [ here!";
$namespaceUrl = null;
$expected = " here!]]>";
$result = XML_Util::createTag($qname, $attributes, $content, $namespaceUrl, XML_UTIL_CDATA_SECTION);
$this->assertEquals($expected, $result, "Failed bugcheck.");
}
}
PK ! YR" " CreateStartElementTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createStartElement($original));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributes()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithEmptyAttributes()
{
$originalTag = "myNs:myTag";
$originalAttributes = "";
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespace()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithEmptyAttributesAndNonUriNamespace()
{
$originalTag = "myTag";
$originalAttributes = "";
$originalNamespace = "foo";
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultiline()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected =
<<< EOF
EOF;
$multiline = true;
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndent()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected =
<<< EOF
EOF;
$multiline = true;
$indent = " ";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreak()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$multiline = true;
$indent = " ";
$linebreak = "^";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsTrue()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = true;
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsFalse()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = false;
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes));
}
}
PK ! ܬ$ GetDocTypeDeclarationTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag"));
}
/**
* @covers XML_Util::getDocTypeDeclaration()
*/
public function testGetDocTypeDeclarationUsingRootAndStringUri()
{
$expected = "";
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", "myDocType.dtd"));
}
/**
* @covers XML_Util::getDocTypeDeclaration()
*/
public function testGetDocTypeDeclarationUsingRootAndArrayUri()
{
$uri = array(
'uri' => 'http://pear.php.net/dtd/package-1.0',
'id' => '-//PHP//PEAR/DTD PACKAGE 0.1'
);
$expected = "";
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri));
}
/**
* @covers XML_Util::getDocTypeDeclaration()
*/
public function testGetDocTypeDeclarationUsingRootAndArrayUriAndInternalDtd()
{
$uri = array(
'uri' => 'http://pear.php.net/dtd/package-1.0',
'id' => '-//PHP//PEAR/DTD PACKAGE 0.1'
);
$dtdEntry = '';
$expected =
<<< EOF
]>
EOF;
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri, $dtdEntry));
}
}
PK ! G Bug21177Tests.phpnu [ ';
return array(
array('', ''),
array('', ''),
array('', ''),
array('', ''),
);
}
/**
* @dataProvider getTestCandidate()
*/
public function testCollapseEmptyTagsForBug21177($original, $expected)
{
$this->assertEquals($expected, XML_Util::collapseEmptyTags($original, XML_UTIL_COLLAPSE_ALL), "Failed bugcheck.");
}
}
PK ! ۩ Bug18343Tests.phpnu [ "install",
"attributes" => array(
"as" => "Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek",
"name" => "test/Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek",
)
);
public function getFlagsToTest()
{
new XML_Util(); // for constants to be declared
return array(
array('no flag', null),
array('false', false),
array('ENTITIES_NONE', XML_UTIL_ENTITIES_NONE),
array('ENTITIES_XML', XML_UTIL_ENTITIES_XML),
array('ENTITIES_XML_REQUIRED', XML_UTIL_ENTITIES_XML_REQUIRED),
array('ENTITIES_HTML', XML_UTIL_ENTITIES_HTML),
array('REPLACE_ENTITIES', XML_UTIL_REPLACE_ENTITIES),
);
}
/**
* @dataProvider getFlagsToTest()
*/
public function testCreateTagFromArrayForBug18343($key, $flag)
{
// all flags for the candidate input should return the same result
$expected =
<<< EOF
EOF;
$this->assertEquals($expected, XML_Util::createTagFromArray($this->tagArray, $flag), "Failed bugcheck for $key.");
}
}
PK ! zt ReverseEntitiesTests.phpnu [ .";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData()));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), 'INVALID_OPTION'));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML), $encoding);
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForUtf8DataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML), $encoding);
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequired()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesHtml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForUtf8DataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding));
}
}
PK ! ~$[e e CreateEndElementTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createEndElement($original));
}
/**
* @covers XML_Util::createEndElement()
*/
public function testCreateEndElementWithNamespacedTag()
{
$original = "myNs:myTag";
$expected = "";
$this->assertEquals($expected, XML_Util::createEndElement($original));
}
}
PK ! ! AbstractUnitTests.phpnu [ "bar");
$expected = "";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContent()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag";
$expected = "This is inside the tag";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespace()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag";
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "This is inside the tag";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithCDataSection()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = " in it]]>";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_CDATA_SECTION));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntities()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineFalse()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = false;
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrue()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$expected =
<<< EOF
This is inside the tag and has < & @ > in it
EOF;
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndent()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$expected =
<<< EOF
This is inside the tag and has < & @ > in it
EOF;
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$linebreak = "^";
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = true;
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = false;
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
}
PK ! Df: GetXmlDeclarationTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::getXMLDeclaration($version));
}
/**
* @covers XML_Util::getXMLDeclaration()
*/
public function testGetXMLDeclarationUsingVersionAndEncodingAndStandalone()
{
$version = "1.0";
$encoding = "UTF-8";
$standalone = true;
$expected = "";
$this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone));
}
/**
* @covers XML_Util::getXMLDeclaration()
*/
public function testGetXMLDeclarationUsingVersionAndStandalone()
{
$version = "1.0";
$encoding = null;
$standalone = true;
$expected = "";
$this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone));
}
}
PK ! Zt AttributesToStringTests.phpnu [ 'bar','boo' => 'baz',);
$expected = " boo=\"baz\" foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitSortTrue()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\" foo=\"bar\"";
$sort = true;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitSortFalse()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " foo=\"bar\" boo=\"baz\"";
$sort = false;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithMultilineFalse()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\" foo=\"bar\"";
$sort = true;
$multiline = false;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithMultilineTrue()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected =
<<< EOF
boo="baz"
foo="bar"
EOF;
$sort = true;
$multiline = true;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitIndent()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\"\n foo=\"bar\"";
$sort = true;
$multiline = true;
$indent = ' '; // 8 spaces
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $indent));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitLinebreak()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\"\n^foo=\"bar\"";
$sort = true;
$multiline = true;
$linebreak = '^'; // some dummy character
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithOptionsThatIncludesSort()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$options = array(
'multiline' => true,
'indent' => '----',
'linebreak' => "^",
'entities' => XML_UTIL_ENTITIES_XML,
'sort' => true,
);
$expected = " boo=\"baz\"\n----foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithOptionsThatExcludesSort()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$options = array(
'multiline' => true,
'indent' => '----',
'linebreak' => "^",
'entities' => XML_UTIL_ENTITIES_XML,
);
$expected = " boo=\"baz\"\n----foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesNone()
{
$original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_NONE));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesXml()
{
$original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesXmlRequired()
{
$original = array("foo" => "b@&r", "boo" => "b><z\" foo=\"b@&r\"";
$sort = true;
$multiline = false;
$linebreak = ' ';
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML_REQUIRED));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesHtml()
{
$original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_HTML));
}
/**
* Tag attributes should not be treated as CDATA,
* so the operation will instead quietly use XML_UTIL_ENTITIES_XML.
*
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithCDataSectionForSingleAttribute()
{
$original = array('foo' => 'bar'); // need exactly one attribute here
$options = array(
'sort' => true, // doesn't matter for this testcase
'multiline' => false, // doesn't matter for this testcase
'indent' => null, // doesn't matter for this testcase
'linebreak' => null, // doesn't matter for this testcase
'entities' => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase
);
$expected = " foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
/**
* Tag attributes should not be treated as CDATA,
* so the operation will instead quietly use XML_UTIL_ENTITIES_XML.
*
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithCDataSectionForMultipleAttributesAndMultilineFalse()
{
$original = array('foo' => 'bar', 'boo' => 'baz'); // need more than one attribute here
$options = array(
'sort' => true, // doesn't matter for this testcase
'multiline' => false, // DOES matter for this testcase, must be false
'indent' => null, // doesn't matter for this testcase
'linebreak' => null, // doesn't matter for this testcase
'entities' => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase
);
$expected = " boo=\"baz\" foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
}
PK ! ݑh IsValidNameTests.phpnu [ assertTrue($result);
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForTagNameWithInvalidCharacter()
{
$tagName = "invalidTag?";
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only contain alphanumeric chars, period, hyphen, colon and underscores";
$this->assertEquals($expectedError, $result->getMessage());
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForTagNameWithInvalidStartingCharacter()
{
$tagName = "1234five";
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only start with letter or underscore";
$this->assertEquals($expectedError, $result->getMessage());
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForInt()
{
$tagName = 1;
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only start with letter or underscore";
$this->assertEquals($expectedError, $result->getMessage());
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForEmptyString()
{
$tagName = '';
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only start with letter or underscore";
$this->assertEquals($expectedError, $result->getMessage());
}
}
PK ! T T CreateCommentTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createComment($original));
}
}
PK ! rv RaiseErrorTests.phpnu [ assertInstanceOf('PEAR_Error', $error);
$this->assertEquals($message, $error->getMessage());
$this->assertEquals($code, $error->getCode());
}
}
PK ! `f3# # . pear/Structures_Graph/tests/BasicGraphTest.phpnu [ |
// +-----------------------------------------------------------------------------+
//
require_once dirname(__FILE__) . '/helper.inc';
/**
* @access private
*/
class BasicGraph extends \PHPUnit\Framework\TestCase
{
var $_graph = null;
function test_create_graph() {
$this->_graph = new Structures_Graph();
$this->assertTrue(is_a($this->_graph, 'Structures_Graph'));
}
function test_add_node() {
$this->_graph = new Structures_Graph();
$data = 1;
$node = new Structures_Graph_Node($data);
$this->_graph->addNode($node);
$node = new Structures_Graph_Node($data);
$this->_graph->addNode($node);
$node = new Structures_Graph_Node($data);
$this->_graph->addNode($node);
$this->assertTrue(true);
}
function test_connect_node() {
$this->_graph = new Structures_Graph();
$data = 1;
$node1 = new Structures_Graph_Node($data);
$node2 = new Structures_Graph_Node($data);
$this->_graph->addNode($node1);
$this->_graph->addNode($node2);
$node1->connectTo($node2);
$node =& $this->_graph->getNodes();
$node =& $node[0];
$node = $node->getNeighbours();
$node =& $node[0];
/*
ZE1 == and === operators fail on $node,$node2 because of the recursion introduced
by the _graph field in the Node object. So, we'll use the stupid method for reference
testing
*/
$node = true;
$this->assertTrue($node2);
$node = false;
$this->assertFalse($node2);
}
function test_data_references() {
$this->_graph = new Structures_Graph();
$data = 1;
$node = new Structures_Graph_Node();
$node->setData($data);
$this->_graph->addNode($node);
$data = 2;
$dataInNode =& $this->_graph->getNodes();
$dataInNode =& $dataInNode[0];
$dataInNode =& $dataInNode->getData();
$this->assertEquals($data, $dataInNode);
}
function test_metadata_references() {
$this->_graph = new Structures_Graph();
$data = 1;
$node = new Structures_Graph_Node();
$node->setMetadata('5', $data);
$data = 2;
$dataInNode =& $node->getMetadata('5');
$this->assertEquals($data, $dataInNode);
}
function test_metadata_key_exists() {
$this->_graph = new Structures_Graph();
$data = 1;
$node = new Structures_Graph_Node();
$node->setMetadata('5', $data);
$this->assertTrue($node->metadataKeyExists('5'));
$this->assertFalse($node->metadataKeyExists('1'));
}
function test_directed_degree() {
$this->_graph = new Structures_Graph(true);
$node = array();
$node[] = new Structures_Graph_Node();
$node[] = new Structures_Graph_Node();
$node[] = new Structures_Graph_Node();
$this->_graph->addNode($node[0]);
$this->_graph->addNode($node[1]);
$this->_graph->addNode($node[2]);
$this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 0 arcs');
$this->assertEquals(0, $node[1]->inDegree(), 'inDegree test failed for node 1 with 0 arcs');
$this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 0 arcs');
$this->assertEquals(0, $node[0]->outDegree(), 'outDegree test failed for node 0 with 0 arcs');
$this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 0 arcs');
$this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 0 arcs');
$node[0]->connectTo($node[1]);
$this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 1 arc');
$this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 1 arc');
$this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 1 arc');
$this->assertEquals(1, $node[0]->outDegree(), 'outDegree test failed for node 0 with 1 arc');
$this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 1 arc');
$this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 1 arc');
$node[0]->connectTo($node[2]);
$this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 2 arcs');
$this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 2 arcs');
$this->assertEquals(1, $node[2]->inDegree(), 'inDegree test failed for node 2 with 2 arcs');
$this->assertEquals(2, $node[0]->outDegree(), 'outDegree test failed for node 0 with 2 arcs');
$this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 2 arcs');
$this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 2 arcs');
}
function test_undirected_degree() {
$this->_graph = new Structures_Graph(false);
$node = array();
$node[] = new Structures_Graph_Node();
$node[] = new Structures_Graph_Node();
$node[] = new Structures_Graph_Node();
$this->_graph->addNode($node[0]);
$this->_graph->addNode($node[1]);
$this->_graph->addNode($node[2]);
$this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 0 arcs');
$this->assertEquals(0, $node[1]->inDegree(), 'inDegree test failed for node 1 with 0 arcs');
$this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 0 arcs');
$this->assertEquals(0, $node[0]->outDegree(), 'outDegree test failed for node 0 with 0 arcs');
$this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 0 arcs');
$this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 0 arcs');
$node[0]->connectTo($node[1]);
$this->assertEquals(1, $node[0]->inDegree(), 'inDegree test failed for node 0 with 1 arc');
$this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 1 arc');
$this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 1 arc');
$this->assertEquals(1, $node[0]->outDegree(), 'outDegree test failed for node 0 with 1 arc');
$this->assertEquals(1, $node[1]->outDegree(), 'outDegree test failed for node 1 with 1 arc');
$this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 1 arc');
$node[0]->connectTo($node[2]);
$this->assertEquals(2, $node[0]->inDegree(), 'inDegree test failed for node 0 with 2 arcs');
$this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 2 arcs');
$this->assertEquals(1, $node[2]->inDegree(), 'inDegree test failed for node 2 with 2 arcs');
$this->assertEquals(2, $node[0]->outDegree(), 'outDegree test failed for node 0 with 2 arcs');
$this->assertEquals(1, $node[1]->outDegree(), 'outDegree test failed for node 1 with 2 arcs');
$this->assertEquals(1, $node[2]->outDegree(), 'outDegree test failed for node 2 with 2 arcs');
}
}
?>
PK ! ;V V 5 pear/Structures_Graph/tests/TopologicalSorterTest.phpnu [ setData($name1);
$graph->addNode($node1);
$name11 = 'node11';
$node11 = new Structures_Graph_Node();
$node11->setData($name11);
$graph->addNode($node11);
$node1->connectTo($node11);
$name12 = 'node12';
$node12 = new Structures_Graph_Node();
$node12->setData($name12);
$graph->addNode($node12);
$node1->connectTo($node12);
$name121 = 'node121';
$node121 = new Structures_Graph_Node();
$node121->setData($name121);
$graph->addNode($node121);
$node12->connectTo($node121);
$name2 = 'node2';
$node2 = new Structures_Graph_Node();
$node2->setData($name2);
$graph->addNode($node2);
$name21 = 'node21';
$node21 = new Structures_Graph_Node();
$node21->setData($name21);
$graph->addNode($node21);
$node2->connectTo($node21);
$nodes = Structures_Graph_Manipulator_TopologicalSorter::sort($graph);
$this->assertCount(2, $nodes[0]);
$this->assertEquals('node1', $nodes[0][0]->getData());
$this->assertEquals('node2', $nodes[0][1]->getData());
$this->assertCount(3, $nodes[1]);
$this->assertEquals('node11', $nodes[1][0]->getData());
$this->assertEquals('node12', $nodes[1][1]->getData());
$this->assertEquals('node21', $nodes[1][2]->getData());
$this->assertCount(1, $nodes[2]);
$this->assertEquals('node121', $nodes[2][0]->getData());
}
}
?>
PK ! e / pear/Structures_Graph/tests/AcyclicTestTest.phpnu [ addNode($node1);
$node2 = new Structures_Graph_Node();
$graph->addNode($node2);
$node1->connectTo($node2);
$node3 = new Structures_Graph_Node();
$graph->addNode($node3);
$node2->connectTo($node3);
$node3->connectTo($node1);
$this->assertFalse(
Structures_Graph_Manipulator_AcyclicTest::isAcyclic($graph),
'Graph is cyclic'
);
}
public function testIsAcyclicTrue()
{
$graph = new Structures_Graph();
$node1 = new Structures_Graph_Node();
$graph->addNode($node1);
$node2 = new Structures_Graph_Node();
$graph->addNode($node2);
$node1->connectTo($node2);
$node3 = new Structures_Graph_Node();
$graph->addNode($node3);
$node2->connectTo($node3);
$this->assertTrue(
Structures_Graph_Manipulator_AcyclicTest::isAcyclic($graph),
'Graph is acyclic'
);
}
}
?>
PK ! 5h t t & pear/Structures_Graph/tests/helper.incnu [ $d) {
if ($i++ > 0) {
print ", ";
}
print $d[0] . '=' . $d[1];
}
print "\n";
print "params: " . implode(", ", $non_opts) . "\n";
print "\n";
}
test("-abc", "abc");
test("-abc foo", "abc");
test("-abc foo", "abc:");
test("-abc foo bar gazonk", "abc");
test("-abc foo bar gazonk", "abc:");
test("-a -b -c", "abc");
test("-a -b -c", "abc:");
test("-abc", "ab:c");
test("-abc foo -bar gazonk", "abc");
?>
--EXPECT--
options: a=, b=, c=
params:
options: a=, b=, c=
params: foo
options: a=, b=, c=foo
params:
options: a=, b=, c=
params: foo, bar, gazonk
options: a=, b=, c=foo
params: bar, gazonk
options: a=, b=, c=
params:
Console_Getopt: option requires an argument --c
options: a=, b=c
params:
options: a=, b=, c=
params: foo, -bar, gazonk
PK ! ' pear/Console_Getopt/tests/bug11068.phptnu [ --TEST--
Console_Getopt [bug 11068]
--SKIPIF--
--FILE--
getMessage()."\n";
echo 'FATAL';
exit;
}
print_r($ret);
?>
--EXPECT--
Array
(
[0] => Array
(
[0] => Array
(
[0] => f
[1] => jjohnston@mail.com
)
[1] => Array
(
[0] => --to
[1] => hi
)
)
[1] => Array
(
[0] => -
)
)PK ! ' pear/Console_Getopt/tests/bug10557.phptnu [ --TEST--
Console_Getopt [bug 10557]
--SKIPIF--
--FILE--
getMessage()."\n";
echo 'FATAL';
exit;
}
print_r($ret);
?>
--EXPECT--
Console_Getopt: option requires an argument --to
FATALPK ! |E E ' pear/Console_Getopt/tests/bug13140.phptnu [ --TEST--
Console_Getopt [bug 13140]
--SKIPIF--
--FILE--
getopt2($cg->readPHPArgv(), 't', array('test'), true));
print_r($cg->getopt2($cg->readPHPArgv(), 'bar', array('foo'), true));
?>
--EXPECT--
Array
(
[0] => Array
(
[0] => Array
(
[0] => --test
[1] =>
)
)
[1] => Array
(
[0] => thisshouldbehere
)
)
Array
(
[0] => Array
(
[0] => Array
(
[0] => --foo
[1] =>
)
[1] => Array
(
[0] => b
[1] =>
)
[2] => Array
(
[0] => a
[1] =>
)
[3] => Array
(
[0] => r
[1] =>
)
[4] => Array
(
[0] => r
[1] =>
)
)
[1] => Array
(
[0] => thisshouldbehere
)
)
PK ! e>4 4 / pear/XML_Util/tests/CreateTagFromArrayTests.phpnu [ "foo:bar",
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespace()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributes()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContent()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndAttributesAndContent()
{
$original = array(
"qname" => "foo:bar",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndContent()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithEntitiesNone()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_ENTITIES_NONE));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntities()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineFalse()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = false;
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrue()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$expected =
<<< EOF
I'm inside the tag
EOF;
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndent()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$expected =
<<< EOF
I'm inside the tag
EOF;
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$linebreak = "^";
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = true;
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse()
{
$original = array(
"qname" => "foo:bar",
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = false;
$expected = "I'm inside the tag";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithInvalidArray()
{
$badArray = array(
"foo" => "bar",
);
$expectedError = "You must either supply a qualified name (qname) or local tag name (localPart).";
$this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithNamespaceAndAttributesAndContentButWithoutQname()
{
$original = array(
"namespaceUri" => "http://foo.com",
"attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ),
"content" => "I'm inside the tag",
);
$expectedError = "You must either supply a qualified name (qname) or local tag name (localPart).";
$this->assertEquals($expectedError, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithNonScalarContent()
{
$badArray = array(
'content' => array('foo', 'bar'),
);
$expectedError = "Supplied non-scalar value as tag content";
$this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithArrayOfNamespaces()
{
$original = array(
'qname' => 'foo:bar',
'namespaces' => array('ns1' => 'uri1', 'ns2' => 'uri2'),
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameDerivedFromNamespaceUriAndLocalPart()
{
$original = array(
'namespaceUri' => 'http://bar.org',
'localPart' => 'foo'
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameDerivedFromNamespaceAndLocalPart()
{
$original = array(
'namespace' => 'http://foo.org',
'localPart' => 'bar'
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithQnameDerivedFromLocalPart()
{
$original = array(
'namespace' => '',
'localPart' => 'bar'
);
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original));
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayWithImplicitlyEmptyContentAndCollapseNoneDoesNotCollapseTag()
{
$original = array('qname' => 'tag1');
$expected = "";
$actual = XML_Util::createTagFromArray(
$original,
XML_UTIL_REPLACE_ENTITIES, // default $replaceEntities
false, // default $multiline
'_auto', // default $indent
"\n", // default $linebreak
true, // default $sortAttributes
XML_UTIL_COLLAPSE_NONE
);
$this->assertEquals($expected, $actual);
}
/**
* @covers XML_Util::createTagFromArray()
*/
public function testCreateTagFromArrayForCdataWithExplicitlyEmptyContentDoesNotCollapseTag()
{
$original = array('qname' => 'tag1', 'content' => '');
$expected = "";
$this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_CDATA_SECTION));
}
}
PK ! C , pear/XML_Util/tests/ReplaceEntitiesTests.phpnu [ .';
}
protected function getUtf8Data()
{
return 'This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê';
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleData()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData()));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), 'INVALID_OPTION'));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForUtf8DataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequired()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesHtml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForSimpleDataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding));
}
/**
* @covers XML_Util::replaceEntities()
*/
public function testReplaceEntitiesForUtf8DataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding));
}
}
PK ! یu ' pear/XML_Util/tests/ApiVersionTests.phpnu [ assertEquals('1.4', XML_Util::apiVersion());
}
}PK ! Gs $ pear/XML_Util/tests/Bug5392Tests.phpnu [ , & and " as well as ä, ö, ß, à and ê';
$replacedResult = XML_Util::replaceEntities($original, XML_UTIL_ENTITIES_HTML, "UTF-8");
$reversedResult = XML_Util::reverseEntities($replacedResult, XML_UTIL_ENTITIES_HTML, "UTF-8");
$this->assertEquals($original, $reversedResult, "Failed bugcheck.");
}
}
PK ! 4ej j / pear/XML_Util/tests/CreateCDataSectionTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createCDataSection($original));
}
}
PK ! |\5 . pear/XML_Util/tests/CollapseEmptyTagsTests.phpnu [ ";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsBasicUsageAlongsideNonemptyTag()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseAll()
{
$emptyTag = "";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagAlongsideEmptyTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyPrefixedTagAlongsideNonemptyTagAlongsideEmptyPrefixedTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyNsPrefixedTagAlongsideNonemptyTagAlongsideEmptyNsPrefixedTagWithCollapseAll()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseXhtml()
{
$emptyTag = "";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_XHTML_ONLY));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseXhtml()
{
$emptyTag = "";
$otherTag = "baz";
$xhtmlTag = "
";
$expected = "
baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $xhtmlTag . $otherTag, XML_UTIL_COLLAPSE_XHTML_ONLY));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseNone()
{
$emptyTag = "";
$expected = "";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_NONE));
}
/**
* @covers XML_Util::collapseEmptyTags()
*/
public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseNone()
{
$emptyTag = "";
$otherTag = "baz";
$expected = "baz";
$this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_NONE));
}
}
PK ! G G / pear/XML_Util/tests/SplitQualifiedNameTests.phpnu [ 'xslt',
'localPart' => 'stylesheet',
);
$this->assertEquals($expected, XML_Util::splitQualifiedName($original));
}
/**
* @covers XML_Util::splitQualifiedName()
*/
public function testSplitQualifiedNameWithNamespace()
{
$original = "stylesheet";
$namespace = "myNs";
$expected = array(
'namespace' => 'myNs',
'localPart' => 'stylesheet',
);
$this->assertEquals($expected, XML_Util::splitQualifiedName($original, $namespace));
}
}
PK ! Yq % pear/XML_Util/tests/Bug21184Tests.phpnu [ one';
$this->assertEquals($xml, XML_Util::collapseEmptyTags($xml, XML_UTIL_COLLAPSE_ALL));
}
}
PK ! >M $ pear/XML_Util/tests/Bug4950Tests.phpnu [ here!";
$namespaceUrl = null;
$expected = " here!]]>";
$result = XML_Util::createTag($qname, $attributes, $content, $namespaceUrl, XML_UTIL_CDATA_SECTION);
$this->assertEquals($expected, $result, "Failed bugcheck.");
}
}
PK ! YR" " / pear/XML_Util/tests/CreateStartElementTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createStartElement($original));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributes()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithEmptyAttributes()
{
$originalTag = "myNs:myTag";
$originalAttributes = "";
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespace()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithEmptyAttributesAndNonUriNamespace()
{
$originalTag = "myTag";
$originalAttributes = "";
$originalNamespace = "foo";
$expected = "";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultiline()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected =
<<< EOF
EOF;
$multiline = true;
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndent()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected =
<<< EOF
EOF;
$multiline = true;
$indent = " ";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreak()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$multiline = true;
$indent = " ";
$linebreak = "^";
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsTrue()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = true;
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createStartElement()
*/
public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsFalse()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = false;
$this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes));
}
}
PK ! ܬ$ 2 pear/XML_Util/tests/GetDocTypeDeclarationTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag"));
}
/**
* @covers XML_Util::getDocTypeDeclaration()
*/
public function testGetDocTypeDeclarationUsingRootAndStringUri()
{
$expected = "";
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", "myDocType.dtd"));
}
/**
* @covers XML_Util::getDocTypeDeclaration()
*/
public function testGetDocTypeDeclarationUsingRootAndArrayUri()
{
$uri = array(
'uri' => 'http://pear.php.net/dtd/package-1.0',
'id' => '-//PHP//PEAR/DTD PACKAGE 0.1'
);
$expected = "";
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri));
}
/**
* @covers XML_Util::getDocTypeDeclaration()
*/
public function testGetDocTypeDeclarationUsingRootAndArrayUriAndInternalDtd()
{
$uri = array(
'uri' => 'http://pear.php.net/dtd/package-1.0',
'id' => '-//PHP//PEAR/DTD PACKAGE 0.1'
);
$dtdEntry = '';
$expected =
<<< EOF
]>
EOF;
$this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri, $dtdEntry));
}
}
PK ! G % pear/XML_Util/tests/Bug21177Tests.phpnu [ ';
return array(
array('', ''),
array('', ''),
array('', ''),
array('', ''),
);
}
/**
* @dataProvider getTestCandidate()
*/
public function testCollapseEmptyTagsForBug21177($original, $expected)
{
$this->assertEquals($expected, XML_Util::collapseEmptyTags($original, XML_UTIL_COLLAPSE_ALL), "Failed bugcheck.");
}
}
PK ! ۩ % pear/XML_Util/tests/Bug18343Tests.phpnu [ "install",
"attributes" => array(
"as" => "Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek",
"name" => "test/Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek",
)
);
public function getFlagsToTest()
{
new XML_Util(); // for constants to be declared
return array(
array('no flag', null),
array('false', false),
array('ENTITIES_NONE', XML_UTIL_ENTITIES_NONE),
array('ENTITIES_XML', XML_UTIL_ENTITIES_XML),
array('ENTITIES_XML_REQUIRED', XML_UTIL_ENTITIES_XML_REQUIRED),
array('ENTITIES_HTML', XML_UTIL_ENTITIES_HTML),
array('REPLACE_ENTITIES', XML_UTIL_REPLACE_ENTITIES),
);
}
/**
* @dataProvider getFlagsToTest()
*/
public function testCreateTagFromArrayForBug18343($key, $flag)
{
// all flags for the candidate input should return the same result
$expected =
<<< EOF
EOF;
$this->assertEquals($expected, XML_Util::createTagFromArray($this->tagArray, $flag), "Failed bugcheck for $key.");
}
}
PK ! zt , pear/XML_Util/tests/ReverseEntitiesTests.phpnu [ .";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData()));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), 'INVALID_OPTION'));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML), $encoding);
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForUtf8DataWithEntitiesXmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML), $encoding);
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequired()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesHtml()
{
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForSimpleDataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This string contains < & >.";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding));
}
/**
* @covers XML_Util::reverseEntities()
*/
public function testReverseEntitiesForUtf8DataWithEntitiesHtmlAndEncoding()
{
$encoding = "UTF-8";
$expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê";
$this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding));
}
}
PK ! ~$[e e - pear/XML_Util/tests/CreateEndElementTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createEndElement($original));
}
/**
* @covers XML_Util::createEndElement()
*/
public function testCreateEndElementWithNamespacedTag()
{
$original = "myNs:myTag";
$expected = "";
$this->assertEquals($expected, XML_Util::createEndElement($original));
}
}
PK ! ! ) pear/XML_Util/tests/AbstractUnitTests.phpnu [ "bar");
$expected = "";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContent()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag";
$expected = "This is inside the tag";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespace()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag";
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "This is inside the tag";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithCDataSection()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = " in it]]>";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_CDATA_SECTION));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntities()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineFalse()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = false;
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrue()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$expected =
<<< EOF
This is inside the tag and has < & @ > in it
EOF;
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndent()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$expected =
<<< EOF
This is inside the tag and has < & @ > in it
EOF;
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$linebreak = "^";
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = true;
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
/**
* @covers XML_Util::createTag()
*/
public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse()
{
$originalTag = "myNs:myTag";
$originalAttributes = array("foo" => "bar", "boo" => "baz");
$originalContent = "This is inside the tag and has < & @ > in it";
$originalNamespace = "http://www.w3c.org/myNs#";
$multiline = true;
$indent = " ";
$linebreak = "^";
$sortAttributes = false;
$expected = "This is inside the tag and has < & @ > in it";
$this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes));
}
}
PK ! Df: . pear/XML_Util/tests/GetXmlDeclarationTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::getXMLDeclaration($version));
}
/**
* @covers XML_Util::getXMLDeclaration()
*/
public function testGetXMLDeclarationUsingVersionAndEncodingAndStandalone()
{
$version = "1.0";
$encoding = "UTF-8";
$standalone = true;
$expected = "";
$this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone));
}
/**
* @covers XML_Util::getXMLDeclaration()
*/
public function testGetXMLDeclarationUsingVersionAndStandalone()
{
$version = "1.0";
$encoding = null;
$standalone = true;
$expected = "";
$this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone));
}
}
PK ! Zt / pear/XML_Util/tests/AttributesToStringTests.phpnu [ 'bar','boo' => 'baz',);
$expected = " boo=\"baz\" foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitSortTrue()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\" foo=\"bar\"";
$sort = true;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitSortFalse()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " foo=\"bar\" boo=\"baz\"";
$sort = false;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithMultilineFalse()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\" foo=\"bar\"";
$sort = true;
$multiline = false;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithMultilineTrue()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected =
<<< EOF
boo="baz"
foo="bar"
EOF;
$sort = true;
$multiline = true;
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitIndent()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\"\n foo=\"bar\"";
$sort = true;
$multiline = true;
$indent = ' '; // 8 spaces
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $indent));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithExplicitLinebreak()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$expected = " boo=\"baz\"\n^foo=\"bar\"";
$sort = true;
$multiline = true;
$linebreak = '^'; // some dummy character
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithOptionsThatIncludesSort()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$options = array(
'multiline' => true,
'indent' => '----',
'linebreak' => "^",
'entities' => XML_UTIL_ENTITIES_XML,
'sort' => true,
);
$expected = " boo=\"baz\"\n----foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithOptionsThatExcludesSort()
{
$original = array('foo' => 'bar','boo' => 'baz',);
$options = array(
'multiline' => true,
'indent' => '----',
'linebreak' => "^",
'entities' => XML_UTIL_ENTITIES_XML,
);
$expected = " boo=\"baz\"\n----foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesNone()
{
$original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_NONE));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesXml()
{
$original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesXmlRequired()
{
$original = array("foo" => "b@&r", "boo" => "b><z\" foo=\"b@&r\"";
$sort = true;
$multiline = false;
$linebreak = ' ';
$this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML_REQUIRED));
}
/**
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithEntitiesHtml()
{
$original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_HTML));
}
/**
* Tag attributes should not be treated as CDATA,
* so the operation will instead quietly use XML_UTIL_ENTITIES_XML.
*
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithCDataSectionForSingleAttribute()
{
$original = array('foo' => 'bar'); // need exactly one attribute here
$options = array(
'sort' => true, // doesn't matter for this testcase
'multiline' => false, // doesn't matter for this testcase
'indent' => null, // doesn't matter for this testcase
'linebreak' => null, // doesn't matter for this testcase
'entities' => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase
);
$expected = " foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
/**
* Tag attributes should not be treated as CDATA,
* so the operation will instead quietly use XML_UTIL_ENTITIES_XML.
*
* @covers XML_Util::attributesToString()
*/
public function testAttributesToStringWithCDataSectionForMultipleAttributesAndMultilineFalse()
{
$original = array('foo' => 'bar', 'boo' => 'baz'); // need more than one attribute here
$options = array(
'sort' => true, // doesn't matter for this testcase
'multiline' => false, // DOES matter for this testcase, must be false
'indent' => null, // doesn't matter for this testcase
'linebreak' => null, // doesn't matter for this testcase
'entities' => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase
);
$expected = " boo=\"baz\" foo=\"bar\"";
$this->assertEquals($expected, XML_Util::attributesToString($original, $options));
}
}
PK ! ݑh ( pear/XML_Util/tests/IsValidNameTests.phpnu [ assertTrue($result);
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForTagNameWithInvalidCharacter()
{
$tagName = "invalidTag?";
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only contain alphanumeric chars, period, hyphen, colon and underscores";
$this->assertEquals($expectedError, $result->getMessage());
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForTagNameWithInvalidStartingCharacter()
{
$tagName = "1234five";
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only start with letter or underscore";
$this->assertEquals($expectedError, $result->getMessage());
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForInt()
{
$tagName = 1;
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only start with letter or underscore";
$this->assertEquals($expectedError, $result->getMessage());
}
/**
* @covers XML_Util::isValidName()
*/
public function testIsValidNameForEmptyString()
{
$tagName = '';
$result = XML_Util::isValidName($tagName);
$this->assertInstanceOf('PEAR_Error', $result);
$expectedError = "XML names may only start with letter or underscore";
$this->assertEquals($expectedError, $result->getMessage());
}
}
PK ! T T * pear/XML_Util/tests/CreateCommentTests.phpnu [ ";
$this->assertEquals($expected, XML_Util::createComment($original));
}
}
PK ! rv ' pear/XML_Util/tests/RaiseErrorTests.phpnu [ assertInstanceOf('PEAR_Error', $error);
$this->assertEquals($message, $error->getMessage());
$this->assertEquals($code, $error->getCode());
}
}
PK ! __init__.pynu [ # -*- coding: utf-8 -*-
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
Test utilities.
"""
from __future__ import print_function
import atexit
import contextlib
import ctypes
import errno
import functools
import os
import random
import re
import select
import shutil
import socket
import stat
import subprocess
import sys
import tempfile
import textwrap
import threading
import time
import traceback
import warnings
from socket import AF_INET
from socket import AF_INET6
from socket import SOCK_DGRAM
from socket import SOCK_STREAM
import psutil
from psutil import OSX
from psutil import POSIX
from psutil import SUNOS
from psutil import WINDOWS
from psutil._common import supports_ipv6
from psutil._compat import PY3
from psutil._compat import u
from psutil._compat import unicode
from psutil._compat import which
if sys.version_info < (2, 7):
import unittest2 as unittest # requires "pip install unittest2"
else:
import unittest
try:
from unittest import mock # py3
except ImportError:
import mock # NOQA - requires "pip install mock"
if sys.version_info >= (3, 4):
import enum
else:
enum = None
__all__ = [
# constants
'APPVEYOR', 'DEVNULL', 'GLOBAL_TIMEOUT', 'MEMORY_TOLERANCE', 'NO_RETRIES',
'PYPY', 'PYTHON_EXE', 'ROOT_DIR', 'SCRIPTS_DIR', 'TESTFILE_PREFIX',
'TESTFN', 'TESTFN_UNICODE', 'TOX', 'TRAVIS', 'VALID_PROC_STATUSES',
'VERBOSITY',
"HAS_CPU_AFFINITY", "HAS_CPU_FREQ", "HAS_ENVIRON", "HAS_PROC_IO_COUNTERS",
"HAS_IONICE", "HAS_MEMORY_MAPS", "HAS_PROC_CPU_NUM", "HAS_RLIMIT",
"HAS_SENSORS_BATTERY", "HAS_BATTERY", "HAS_SENSORS_FANS",
"HAS_SENSORS_TEMPERATURES", "HAS_MEMORY_FULL_INFO",
# subprocesses
'pyrun', 'reap_children', 'get_test_subprocess', 'create_zombie_proc',
'create_proc_children_pair',
# threads
'ThreadTask'
# test utils
'unittest', 'skip_on_access_denied', 'skip_on_not_implemented',
'retry_before_failing', 'run_test_module_by_name', 'get_suite',
'run_suite',
# install utils
'install_pip', 'install_test_deps',
# fs utils
'chdir', 'safe_rmpath', 'create_exe', 'decode_path', 'encode_path',
'unique_filename',
# os
'get_winver', 'get_kernel_version',
# sync primitives
'call_until', 'wait_for_pid', 'wait_for_file',
# network
'check_connection_ntuple', 'check_net_address',
'get_free_port', 'unix_socket_path', 'bind_socket', 'bind_unix_socket',
'tcp_socketpair', 'unix_socketpair', 'create_sockets',
# compat
'reload_module', 'import_module_by_path',
# others
'warn', 'copyload_shared_lib', 'is_namedtuple',
]
# ===================================================================
# --- constants
# ===================================================================
# --- platforms
TOX = os.getenv('TOX') or '' in ('1', 'true')
PYPY = '__pypy__' in sys.builtin_module_names
WIN_VISTA = (6, 0, 0) if WINDOWS else None
# whether we're running this test suite on Travis (https://travis-ci.org/)
TRAVIS = bool(os.environ.get('TRAVIS'))
# whether we're running this test suite on Appveyor for Windows
# (http://www.appveyor.com/)
APPVEYOR = bool(os.environ.get('APPVEYOR'))
# --- configurable defaults
# how many times retry_before_failing() decorator will retry
NO_RETRIES = 10
# bytes tolerance for system-wide memory related tests
MEMORY_TOLERANCE = 500 * 1024 # 500KB
# the timeout used in functions which have to wait
GLOBAL_TIMEOUT = 3
# test output verbosity
VERBOSITY = 1 if os.getenv('SILENT') or TOX else 2
# be more tolerant if we're on travis / appveyor in order to avoid
# false positives
if TRAVIS or APPVEYOR:
NO_RETRIES *= 3
GLOBAL_TIMEOUT *= 3
# --- files
TESTFILE_PREFIX = '$testfn'
TESTFN = os.path.join(os.path.realpath(os.getcwd()), TESTFILE_PREFIX)
_TESTFN = TESTFN + '-internal'
TESTFN_UNICODE = TESTFN + u("-ƒőő")
ASCII_FS = sys.getfilesystemencoding().lower() in ('ascii', 'us-ascii')
# --- paths
ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
SCRIPTS_DIR = os.path.join(ROOT_DIR, 'scripts')
HERE = os.path.abspath(os.path.dirname(__file__))
# --- support
HAS_CPU_AFFINITY = hasattr(psutil.Process, "cpu_affinity")
HAS_CPU_FREQ = hasattr(psutil, "cpu_freq")
HAS_CONNECTIONS_UNIX = POSIX and not SUNOS
HAS_ENVIRON = hasattr(psutil.Process, "environ")
HAS_PROC_IO_COUNTERS = hasattr(psutil.Process, "io_counters")
HAS_IONICE = hasattr(psutil.Process, "ionice")
HAS_MEMORY_FULL_INFO = 'uss' in psutil.Process().memory_full_info()._fields
HAS_MEMORY_MAPS = hasattr(psutil.Process, "memory_maps")
HAS_PROC_CPU_NUM = hasattr(psutil.Process, "cpu_num")
HAS_RLIMIT = hasattr(psutil.Process, "rlimit")
HAS_THREADS = hasattr(psutil.Process, "threads")
HAS_SENSORS_BATTERY = hasattr(psutil, "sensors_battery")
HAS_BATTERY = HAS_SENSORS_BATTERY and psutil.sensors_battery()
HAS_SENSORS_FANS = hasattr(psutil, "sensors_fans")
HAS_SENSORS_TEMPERATURES = hasattr(psutil, "sensors_temperatures")
# --- misc
def _get_py_exe():
def attempt(exe):
try:
subprocess.check_call(
[exe, "-V"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
except Exception:
return None
else:
return exe
if OSX:
exe = \
attempt(sys.executable) or \
attempt(os.path.realpath(sys.executable)) or \
attempt(which("python%s.%s" % sys.version_info[:2])) or \
attempt(psutil.Process().exe())
if not exe:
raise ValueError("can't find python exe real abspath")
return exe
else:
exe = os.path.realpath(sys.executable)
assert os.path.exists(exe), exe
return exe
PYTHON_EXE = _get_py_exe()
DEVNULL = open(os.devnull, 'r+')
VALID_PROC_STATUSES = [getattr(psutil, x) for x in dir(psutil)
if x.startswith('STATUS_')]
AF_UNIX = getattr(socket, "AF_UNIX", object())
SOCK_SEQPACKET = getattr(socket, "SOCK_SEQPACKET", object())
_subprocesses_started = set()
_pids_started = set()
_testfiles_created = set()
@atexit.register
def _cleanup_files():
DEVNULL.close()
for name in os.listdir(u('.')):
if isinstance(name, unicode):
prefix = u(TESTFILE_PREFIX)
else:
prefix = TESTFILE_PREFIX
if name.startswith(prefix):
try:
safe_rmpath(name)
except Exception:
traceback.print_exc()
for path in _testfiles_created:
try:
safe_rmpath(path)
except Exception:
traceback.print_exc()
# this is executed first
@atexit.register
def _cleanup_procs():
reap_children(recursive=True)
# ===================================================================
# --- threads
# ===================================================================
class ThreadTask(threading.Thread):
"""A thread task which does nothing expect staying alive."""
def __init__(self):
threading.Thread.__init__(self)
self._running = False
self._interval = 0.001
self._flag = threading.Event()
def __repr__(self):
name = self.__class__.__name__
return '<%s running=%s at %#x>' % (name, self._running, id(self))
def __enter__(self):
self.start()
return self
def __exit__(self, *args, **kwargs):
self.stop()
def start(self):
"""Start thread and keep it running until an explicit
stop() request. Polls for shutdown every 'timeout' seconds.
"""
if self._running:
raise ValueError("already started")
threading.Thread.start(self)
self._flag.wait()
def run(self):
self._running = True
self._flag.set()
while self._running:
time.sleep(self._interval)
def stop(self):
"""Stop thread execution and and waits until it is stopped."""
if not self._running:
raise ValueError("already stopped")
self._running = False
self.join()
# ===================================================================
# --- subprocesses
# ===================================================================
def _cleanup_on_err(fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs):
try:
return fun(*args, **kwargs)
except Exception:
reap_children()
raise
return wrapper
@_cleanup_on_err
def get_test_subprocess(cmd=None, **kwds):
"""Creates a python subprocess which does nothing for 60 secs and
return it as subprocess.Popen instance.
If "cmd" is specified that is used instead of python.
By default stdin and stdout are redirected to /dev/null.
It also attemps to make sure the process is in a reasonably
initialized state.
The process is registered for cleanup on reap_children().
"""
kwds.setdefault("stdin", DEVNULL)
kwds.setdefault("stdout", DEVNULL)
kwds.setdefault("cwd", os.getcwd())
kwds.setdefault("env", os.environ)
if WINDOWS:
# Prevents the subprocess to open error dialogs.
kwds.setdefault("creationflags", 0x8000000) # CREATE_NO_WINDOW
if cmd is None:
safe_rmpath(_TESTFN)
pyline = "from time import sleep;" \
"open(r'%s', 'w').close();" \
"sleep(60);" % _TESTFN
cmd = [PYTHON_EXE, "-c", pyline]
sproc = subprocess.Popen(cmd, **kwds)
_subprocesses_started.add(sproc)
wait_for_file(_TESTFN, delete=True, empty=True)
else:
sproc = subprocess.Popen(cmd, **kwds)
_subprocesses_started.add(sproc)
wait_for_pid(sproc.pid)
return sproc
@_cleanup_on_err
def create_proc_children_pair():
"""Create a subprocess which creates another one as in:
A (us) -> B (child) -> C (grandchild).
Return a (child, grandchild) tuple.
The 2 processes are fully initialized and will live for 60 secs
and are registered for cleanup on reap_children().
"""
_TESTFN2 = os.path.basename(_TESTFN) + '2' # need to be relative
s = textwrap.dedent("""\
import subprocess, os, sys, time
s = "import os, time;"
s += "f = open('%s', 'w');"
s += "f.write(str(os.getpid()));"
s += "f.close();"
s += "time.sleep(60);"
subprocess.Popen(['%s', '-c', s])
time.sleep(60)
""" % (_TESTFN2, PYTHON_EXE))
# On Windows if we create a subprocess with CREATE_NO_WINDOW flag
# set (which is the default) a "conhost.exe" extra process will be
# spawned as a child. We don't want that.
if WINDOWS:
subp = pyrun(s, creationflags=0)
else:
subp = pyrun(s)
child1 = psutil.Process(subp.pid)
data = wait_for_file(_TESTFN2, delete=False, empty=False)
os.remove(_TESTFN2)
child2_pid = int(data)
_pids_started.add(child2_pid)
child2 = psutil.Process(child2_pid)
return (child1, child2)
def create_zombie_proc():
"""Create a zombie process and return its PID."""
assert psutil.POSIX
unix_file = tempfile.mktemp(prefix=TESTFILE_PREFIX) if OSX else TESTFN
src = textwrap.dedent("""\
import os, sys, time, socket, contextlib
child_pid = os.fork()
if child_pid > 0:
time.sleep(3000)
else:
# this is the zombie process
s = socket.socket(socket.AF_UNIX)
with contextlib.closing(s):
s.connect('%s')
if sys.version_info < (3, ):
pid = str(os.getpid())
else:
pid = bytes(str(os.getpid()), 'ascii')
s.sendall(pid)
""" % unix_file)
with contextlib.closing(socket.socket(socket.AF_UNIX)) as sock:
sock.settimeout(GLOBAL_TIMEOUT)
sock.bind(unix_file)
sock.listen(1)
pyrun(src)
conn, _ = sock.accept()
try:
select.select([conn.fileno()], [], [], GLOBAL_TIMEOUT)
zpid = int(conn.recv(1024))
_pids_started.add(zpid)
zproc = psutil.Process(zpid)
call_until(lambda: zproc.status(), "ret == psutil.STATUS_ZOMBIE")
return zpid
finally:
conn.close()
@_cleanup_on_err
def pyrun(src, **kwds):
"""Run python 'src' code string in a separate interpreter.
Returns a subprocess.Popen instance.
"""
kwds.setdefault("stdout", None)
kwds.setdefault("stderr", None)
with tempfile.NamedTemporaryFile(
prefix=TESTFILE_PREFIX, mode="wt", delete=False) as f:
_testfiles_created.add(f.name)
f.write(src)
f.flush()
subp = get_test_subprocess([PYTHON_EXE, f.name], **kwds)
wait_for_pid(subp.pid)
return subp
@_cleanup_on_err
def sh(cmd, **kwds):
"""run cmd in a subprocess and return its output.
raises RuntimeError on error.
"""
shell = True if isinstance(cmd, (str, unicode)) else False
# Prevents subprocess to open error dialogs in case of error.
flags = 0x8000000 if WINDOWS and shell else 0
kwds.setdefault("shell", shell)
kwds.setdefault("stdout", subprocess.PIPE)
kwds.setdefault("stderr", subprocess.PIPE)
kwds.setdefault("universal_newlines", True)
kwds.setdefault("creationflags", flags)
p = subprocess.Popen(cmd, **kwds)
_subprocesses_started.add(p)
stdout, stderr = p.communicate()
if p.returncode != 0:
raise RuntimeError(stderr)
if stderr:
warn(stderr)
if stdout.endswith('\n'):
stdout = stdout[:-1]
return stdout
def reap_children(recursive=False):
"""Terminate and wait() any subprocess started by this test suite
and ensure that no zombies stick around to hog resources and
create problems when looking for refleaks.
If resursive is True it also tries to terminate and wait()
all grandchildren started by this process.
"""
# This is here to make sure wait_procs() behaves properly and
# investigate:
# https://ci.appveyor.com/project/giampaolo/psutil/build/job/
# jiq2cgd6stsbtn60
def assert_gone(pid):
assert not psutil.pid_exists(pid), pid
assert pid not in psutil.pids(), pid
try:
p = psutil.Process(pid)
assert not p.is_running(), pid
except psutil.NoSuchProcess:
pass
else:
assert 0, "pid %s is not gone" % pid
# Get the children here, before terminating the children sub
# processes as we don't want to lose the intermediate reference
# in case of grandchildren.
if recursive:
children = set(psutil.Process().children(recursive=True))
else:
children = set()
# Terminate subprocess.Popen instances "cleanly" by closing their
# fds and wiat()ing for them in order to avoid zombies.
while _subprocesses_started:
subp = _subprocesses_started.pop()
_pids_started.add(subp.pid)
try:
subp.terminate()
except OSError as err:
if err.errno != errno.ESRCH:
raise
if subp.stdout:
subp.stdout.close()
if subp.stderr:
subp.stderr.close()
try:
# Flushing a BufferedWriter may raise an error.
if subp.stdin:
subp.stdin.close()
finally:
# Wait for the process to terminate, to avoid zombies.
try:
subp.wait()
except OSError as err:
if err.errno != errno.ECHILD:
raise
# Terminate started pids.
while _pids_started:
pid = _pids_started.pop()
try:
p = psutil.Process(pid)
except psutil.NoSuchProcess:
assert_gone(pid)
else:
children.add(p)
# Terminate children.
if children:
for p in children:
try:
p.terminate()
except psutil.NoSuchProcess:
pass
gone, alive = psutil.wait_procs(children, timeout=GLOBAL_TIMEOUT)
for p in alive:
warn("couldn't terminate process %r; attempting kill()" % p)
try:
p.kill()
except psutil.NoSuchProcess:
pass
gone, alive = psutil.wait_procs(alive, timeout=GLOBAL_TIMEOUT)
if alive:
for p in alive:
warn("process %r survived kill()" % p)
for p in children:
assert_gone(p.pid)
# ===================================================================
# --- OS
# ===================================================================
def get_kernel_version():
"""Return a tuple such as (2, 6, 36)."""
if not POSIX:
raise NotImplementedError("not POSIX")
s = ""
uname = os.uname()[2]
for c in uname:
if c.isdigit() or c == '.':
s += c
else:
break
if not s:
raise ValueError("can't parse %r" % uname)
minor = 0
micro = 0
nums = s.split('.')
major = int(nums[0])
if len(nums) >= 2:
minor = int(nums[1])
if len(nums) >= 3:
micro = int(nums[2])
return (major, minor, micro)
def get_winver():
if not WINDOWS:
raise NotImplementedError("not WINDOWS")
wv = sys.getwindowsversion()
if hasattr(wv, 'service_pack_major'): # python >= 2.7
sp = wv.service_pack_major or 0
else:
r = re.search(r"\s\d$", wv[4])
if r:
sp = int(r.group(0))
else:
sp = 0
return (wv[0], wv[1], sp)
# ===================================================================
# --- sync primitives
# ===================================================================
class retry(object):
"""A retry decorator."""
def __init__(self,
exception=Exception,
timeout=None,
retries=None,
interval=0.001,
logfun=lambda s: print(s, file=sys.stderr),
):
if timeout and retries:
raise ValueError("timeout and retries args are mutually exclusive")
self.exception = exception
self.timeout = timeout
self.retries = retries
self.interval = interval
self.logfun = logfun
def __iter__(self):
if self.timeout:
stop_at = time.time() + self.timeout
while time.time() < stop_at:
yield
elif self.retries:
for _ in range(self.retries):
yield
else:
while True:
yield
def sleep(self):
if self.interval is not None:
time.sleep(self.interval)
def __call__(self, fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs):
exc = None
for _ in self:
try:
return fun(*args, **kwargs)
except self.exception as _:
exc = _
if self.logfun is not None:
self.logfun(exc)
self.sleep()
continue
if PY3:
raise exc
else:
raise
# This way the user of the decorated function can change config
# parameters.
wrapper.decorator = self
return wrapper
@retry(exception=psutil.NoSuchProcess, logfun=None, timeout=GLOBAL_TIMEOUT,
interval=0.001)
def wait_for_pid(pid):
"""Wait for pid to show up in the process list then return.
Used in the test suite to give time the sub process to initialize.
"""
psutil.Process(pid)
if WINDOWS:
# give it some more time to allow better initialization
time.sleep(0.01)
@retry(exception=(EnvironmentError, AssertionError), logfun=None,
timeout=GLOBAL_TIMEOUT, interval=0.001)
def wait_for_file(fname, delete=True, empty=False):
"""Wait for a file to be written on disk with some content."""
with open(fname, "rb") as f:
data = f.read()
if not empty:
assert data
if delete:
os.remove(fname)
return data
@retry(exception=AssertionError, logfun=None, timeout=GLOBAL_TIMEOUT,
interval=0.001)
def call_until(fun, expr):
"""Keep calling function for timeout secs and exit if eval()
expression is True.
"""
ret = fun()
assert eval(expr)
return ret
# ===================================================================
# --- fs
# ===================================================================
def safe_rmpath(path):
"Convenience function for removing temporary test files or dirs"
try:
st = os.stat(path)
if stat.S_ISDIR(st.st_mode):
os.rmdir(path)
else:
os.remove(path)
except OSError as err:
if err.errno != errno.ENOENT:
raise
def safe_mkdir(dir):
"Convenience function for creating a directory"
try:
os.mkdir(dir)
except OSError as err:
if err.errno != errno.EEXIST:
raise
@contextlib.contextmanager
def chdir(dirname):
"Context manager which temporarily changes the current directory."
curdir = os.getcwd()
try:
os.chdir(dirname)
yield
finally:
os.chdir(curdir)
def create_exe(outpath, c_code=None):
"""Creates an executable file in the given location."""
assert not os.path.exists(outpath), outpath
if c_code:
if not which("gcc"):
raise ValueError("gcc is not installed")
if isinstance(c_code, bool): # c_code is True
c_code = textwrap.dedent(
"""
#include
int main() {
pause();
return 1;
}
""")
assert isinstance(c_code, str), c_code
with tempfile.NamedTemporaryFile(
suffix='.c', delete=False, mode='wt') as f:
f.write(c_code)
try:
subprocess.check_call(["gcc", f.name, "-o", outpath])
finally:
safe_rmpath(f.name)
else:
# copy python executable
shutil.copyfile(PYTHON_EXE, outpath)
if POSIX:
st = os.stat(outpath)
os.chmod(outpath, st.st_mode | stat.S_IEXEC)
def unique_filename(prefix=TESTFILE_PREFIX, suffix=""):
return tempfile.mktemp(prefix=prefix, suffix=suffix)
# ===================================================================
# --- testing
# ===================================================================
class TestCase(unittest.TestCase):
# Print a full path representation of the single unit tests
# being run.
def __str__(self):
return "%s.%s.%s" % (
self.__class__.__module__, self.__class__.__name__,
self._testMethodName)
# assertRaisesRegexp renamed to assertRaisesRegex in 3.3;
# add support for the new name.
if not hasattr(unittest.TestCase, 'assertRaisesRegex'):
assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
# override default unittest.TestCase
unittest.TestCase = TestCase
def _setup_tests():
if 'PSUTIL_TESTING' not in os.environ:
# This won't work on Windows but set_testing() below will do it.
os.environ['PSUTIL_TESTING'] = '1'
psutil._psplatform.cext.set_testing()
def get_suite():
testmods = [os.path.splitext(x)[0] for x in os.listdir(HERE)
if x.endswith('.py') and x.startswith('test_') and not
x.startswith('test_memory_leaks')]
if "WHEELHOUSE_UPLOADER_USERNAME" in os.environ:
testmods = [x for x in testmods if not x.endswith((
"osx", "posix", "linux"))]
suite = unittest.TestSuite()
for tm in testmods:
# ...so that the full test paths are printed on screen
tm = "psutil.tests.%s" % tm
suite.addTest(unittest.defaultTestLoader.loadTestsFromName(tm))
return suite
def run_suite():
_setup_tests()
result = unittest.TextTestRunner(verbosity=VERBOSITY).run(get_suite())
success = result.wasSuccessful()
sys.exit(0 if success else 1)
def run_test_module_by_name(name):
# testmodules = [os.path.splitext(x)[0] for x in os.listdir(HERE)
# if x.endswith('.py') and x.startswith('test_')]
_setup_tests()
name = os.path.splitext(os.path.basename(name))[0]
suite = unittest.TestSuite()
suite.addTest(unittest.defaultTestLoader.loadTestsFromName(name))
result = unittest.TextTestRunner(verbosity=VERBOSITY).run(suite)
success = result.wasSuccessful()
sys.exit(0 if success else 1)
def retry_before_failing(retries=NO_RETRIES):
"""Decorator which runs a test function and retries N times before
actually failing.
"""
return retry(exception=AssertionError, timeout=None, retries=retries)
def skip_on_access_denied(only_if=None):
"""Decorator to Ignore AccessDenied exceptions."""
def decorator(fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs):
try:
return fun(*args, **kwargs)
except psutil.AccessDenied:
if only_if is not None:
if not only_if:
raise
raise unittest.SkipTest("raises AccessDenied")
return wrapper
return decorator
def skip_on_not_implemented(only_if=None):
"""Decorator to Ignore NotImplementedError exceptions."""
def decorator(fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs):
try:
return fun(*args, **kwargs)
except NotImplementedError:
if only_if is not None:
if not only_if:
raise
msg = "%r was skipped because it raised NotImplementedError" \
% fun.__name__
raise unittest.SkipTest(msg)
return wrapper
return decorator
# ===================================================================
# --- network
# ===================================================================
def get_free_port(host='127.0.0.1'):
"""Return an unused TCP port."""
with contextlib.closing(socket.socket()) as sock:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((host, 0))
return sock.getsockname()[1]
@contextlib.contextmanager
def unix_socket_path(suffix=""):
"""A context manager which returns a non-existent file name
and tries to delete it on exit.
"""
assert psutil.POSIX
path = unique_filename(suffix=suffix)
try:
yield path
finally:
try:
os.unlink(path)
except OSError:
pass
def bind_socket(family=AF_INET, type=SOCK_STREAM, addr=None):
"""Binds a generic socket."""
if addr is None and family in (AF_INET, AF_INET6):
addr = ("", 0)
sock = socket.socket(family, type)
try:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(addr)
if type == socket.SOCK_STREAM:
sock.listen(10)
return sock
except Exception:
sock.close()
raise
def bind_unix_socket(name, type=socket.SOCK_STREAM):
"""Bind a UNIX socket."""
assert psutil.POSIX
assert not os.path.exists(name), name
sock = socket.socket(socket.AF_UNIX, type)
try:
sock.bind(name)
if type == socket.SOCK_STREAM:
sock.listen(10)
except Exception:
sock.close()
raise
return sock
def tcp_socketpair(family, addr=("", 0)):
"""Build a pair of TCP sockets connected to each other.
Return a (server, client) tuple.
"""
with contextlib.closing(socket.socket(family, SOCK_STREAM)) as ll:
ll.bind(addr)
ll.listen(10)
addr = ll.getsockname()
c = socket.socket(family, SOCK_STREAM)
try:
c.connect(addr)
caddr = c.getsockname()
while True:
a, addr = ll.accept()
# check that we've got the correct client
if addr == caddr:
return (a, c)
a.close()
except OSError:
c.close()
raise
def unix_socketpair(name):
"""Build a pair of UNIX sockets connected to each other through
the same UNIX file name.
Return a (server, client) tuple.
"""
assert psutil.POSIX
server = client = None
try:
server = bind_unix_socket(name, type=socket.SOCK_STREAM)
server.setblocking(0)
client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
client.setblocking(0)
client.connect(name)
# new = server.accept()
except Exception:
if server is not None:
server.close()
if client is not None:
client.close()
raise
return (server, client)
@contextlib.contextmanager
def create_sockets():
"""Open as many socket families / types as possible."""
socks = []
fname1 = fname2 = None
try:
socks.append(bind_socket(socket.AF_INET, socket.SOCK_STREAM))
socks.append(bind_socket(socket.AF_INET, socket.SOCK_DGRAM))
if supports_ipv6():
socks.append(bind_socket(socket.AF_INET6, socket.SOCK_STREAM))
socks.append(bind_socket(socket.AF_INET6, socket.SOCK_DGRAM))
if POSIX and HAS_CONNECTIONS_UNIX:
fname1 = unix_socket_path().__enter__()
fname2 = unix_socket_path().__enter__()
s1, s2 = unix_socketpair(fname1)
s3 = bind_unix_socket(fname2, type=socket.SOCK_DGRAM)
# self.addCleanup(safe_rmpath, fname1)
# self.addCleanup(safe_rmpath, fname2)
for s in (s1, s2, s3):
socks.append(s)
yield socks
finally:
for s in socks:
s.close()
if fname1 is not None:
safe_rmpath(fname1)
if fname2 is not None:
safe_rmpath(fname2)
def check_net_address(addr, family):
"""Check a net address validity. Supported families are IPv4,
IPv6 and MAC addresses.
"""
import ipaddress # python >= 3.3 / requires "pip install ipaddress"
if enum and PY3:
assert isinstance(family, enum.IntEnum), family
if family == socket.AF_INET:
octs = [int(x) for x in addr.split('.')]
assert len(octs) == 4, addr
for num in octs:
assert 0 <= num <= 255, addr
if not PY3:
addr = unicode(addr)
ipaddress.IPv4Address(addr)
elif family == socket.AF_INET6:
assert isinstance(addr, str), addr
if not PY3:
addr = unicode(addr)
ipaddress.IPv6Address(addr)
elif family == psutil.AF_LINK:
assert re.match(r'([a-fA-F0-9]{2}[:|\-]?){6}', addr) is not None, addr
else:
raise ValueError("unknown family %r", family)
def check_connection_ntuple(conn):
"""Check validity of a connection namedtuple."""
# check ntuple
assert len(conn) in (6, 7), conn
has_pid = len(conn) == 7
has_fd = getattr(conn, 'fd', -1) != -1
assert conn[0] == conn.fd
assert conn[1] == conn.family
assert conn[2] == conn.type
assert conn[3] == conn.laddr
assert conn[4] == conn.raddr
assert conn[5] == conn.status
if has_pid:
assert conn[6] == conn.pid
# check fd
if has_fd:
assert conn.fd >= 0, conn
if hasattr(socket, 'fromfd') and not WINDOWS:
try:
dupsock = socket.fromfd(conn.fd, conn.family, conn.type)
except (socket.error, OSError) as err:
if err.args[0] != errno.EBADF:
raise
else:
with contextlib.closing(dupsock):
assert dupsock.family == conn.family
assert dupsock.type == conn.type
# check family
assert conn.family in (AF_INET, AF_INET6, AF_UNIX), repr(conn.family)
if conn.family in (AF_INET, AF_INET6):
# actually try to bind the local socket; ignore IPv6
# sockets as their address might be represented as
# an IPv4-mapped-address (e.g. "::127.0.0.1")
# and that's rejected by bind()
if conn.family == AF_INET:
s = socket.socket(conn.family, conn.type)
with contextlib.closing(s):
try:
s.bind((conn.laddr[0], 0))
except socket.error as err:
if err.errno != errno.EADDRNOTAVAIL:
raise
elif conn.family == AF_UNIX:
assert conn.status == psutil.CONN_NONE, conn.status
# check type (SOCK_SEQPACKET may happen in case of AF_UNIX socks)
assert conn.type in (SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET), \
repr(conn.type)
if conn.type == SOCK_DGRAM:
assert conn.status == psutil.CONN_NONE, conn.status
# check laddr (IP address and port sanity)
for addr in (conn.laddr, conn.raddr):
if conn.family in (AF_INET, AF_INET6):
assert isinstance(addr, tuple), addr
if not addr:
continue
assert isinstance(addr.port, int), addr.port
assert 0 <= addr.port <= 65535, addr.port
check_net_address(addr.ip, conn.family)
elif conn.family == AF_UNIX:
assert isinstance(addr, str), addr
# check status
assert isinstance(conn.status, str), conn
valids = [getattr(psutil, x) for x in dir(psutil) if x.startswith('CONN_')]
assert conn.status in valids, conn
# ===================================================================
# --- compatibility
# ===================================================================
def reload_module(module):
"""Backport of importlib.reload of Python 3.3+."""
try:
import importlib
if not hasattr(importlib, 'reload'): # python <=3.3
raise ImportError
except ImportError:
import imp
return imp.reload(module)
else:
return importlib.reload(module)
def import_module_by_path(path):
name = os.path.splitext(os.path.basename(path))[0]
if sys.version_info[0] == 2:
import imp
return imp.load_source(name, path)
elif sys.version_info[:2] <= (3, 4):
from importlib.machinery import SourceFileLoader
return SourceFileLoader(name, path).load_module()
else:
import importlib.util
spec = importlib.util.spec_from_file_location(name, path)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
# ===================================================================
# --- others
# ===================================================================
def warn(msg):
"""Raise a warning msg."""
warnings.warn(msg, UserWarning)
def is_namedtuple(x):
"""Check if object is an instance of namedtuple."""
t = type(x)
b = t.__bases__
if len(b) != 1 or b[0] != tuple:
return False
f = getattr(t, '_fields', None)
if not isinstance(f, tuple):
return False
return all(type(n) == str for n in f)
if POSIX:
@contextlib.contextmanager
def copyload_shared_lib(dst_prefix=TESTFILE_PREFIX):
"""Ctx manager which picks up a random shared CO lib used
by this process, copies it in another location and loads it
in memory via ctypes. Return the new absolutized path.
"""
ext = ".so"
dst = tempfile.mktemp(prefix=dst_prefix, suffix=ext)
libs = [x.path for x in psutil.Process().memory_maps() if
os.path.splitext(x.path)[1] == ext and
'python' in x.path.lower()]
src = random.choice(libs)
shutil.copyfile(src, dst)
try:
ctypes.CDLL(dst)
yield dst
finally:
safe_rmpath(dst)
else:
@contextlib.contextmanager
def copyload_shared_lib(dst_prefix=TESTFILE_PREFIX):
"""Ctx manager which picks up a random shared DLL lib used
by this process, copies it in another location and loads it
in memory via ctypes.
Return the new absolutized, normcased path.
"""
from ctypes import wintypes
from ctypes import WinError
ext = ".dll"
dst = tempfile.mktemp(prefix=dst_prefix, suffix=ext)
libs = [x.path for x in psutil.Process().memory_maps() if
os.path.splitext(x.path)[1].lower() == ext and
'python' in os.path.basename(x.path).lower() and
'wow64' not in x.path.lower()]
src = random.choice(libs)
shutil.copyfile(src, dst)
cfile = None
try:
cfile = ctypes.WinDLL(dst)
yield dst
finally:
# Work around OverflowError:
# - https://ci.appveyor.com/project/giampaolo/psutil/build/1207/
# job/o53330pbnri9bcw7
# - http://bugs.python.org/issue30286
# - http://stackoverflow.com/questions/23522055
if cfile is not None:
FreeLibrary = ctypes.windll.kernel32.FreeLibrary
FreeLibrary.argtypes = [wintypes.HMODULE]
ret = FreeLibrary(cfile._handle)
if ret == 0:
WinError()
safe_rmpath(dst)
PK ! wӷK K test_windows.pynu [ # -*- coding: UTF-8 -*
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Windows specific tests."""
import datetime
import errno
import glob
import os
import platform
import re
import signal
import subprocess
import sys
import time
import warnings
import psutil
from psutil import WINDOWS
from psutil._compat import callable
from psutil.tests import APPVEYOR
from psutil.tests import get_test_subprocess
from psutil.tests import HAS_BATTERY
from psutil.tests import mock
from psutil.tests import reap_children
from psutil.tests import retry_before_failing
from psutil.tests import run_test_module_by_name
from psutil.tests import sh
from psutil.tests import unittest
with warnings.catch_warnings():
warnings.simplefilter("ignore")
try:
import win32api # requires "pip install pypiwin32"
import win32con
import win32process
import wmi # requires "pip install wmi" / "make setup-dev-env"
except ImportError:
if os.name == 'nt':
raise
cext = psutil._psplatform.cext
# are we a 64 bit process
IS_64_BIT = sys.maxsize > 2**32
def wrap_exceptions(fun):
def wrapper(self, *args, **kwargs):
try:
return fun(self, *args, **kwargs)
except OSError as err:
from psutil._pswindows import ACCESS_DENIED_SET
if err.errno in ACCESS_DENIED_SET:
raise psutil.AccessDenied(None, None)
if err.errno == errno.ESRCH:
raise psutil.NoSuchProcess(None, None)
raise
return wrapper
# ===================================================================
# System APIs
# ===================================================================
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class TestSystemAPIs(unittest.TestCase):
def test_nic_names(self):
out = sh('ipconfig /all')
nics = psutil.net_io_counters(pernic=True).keys()
for nic in nics:
if "pseudo-interface" in nic.replace(' ', '-').lower():
continue
if nic not in out:
self.fail(
"%r nic wasn't found in 'ipconfig /all' output" % nic)
@unittest.skipIf('NUMBER_OF_PROCESSORS' not in os.environ,
'NUMBER_OF_PROCESSORS env var is not available')
def test_cpu_count(self):
num_cpus = int(os.environ['NUMBER_OF_PROCESSORS'])
self.assertEqual(num_cpus, psutil.cpu_count())
def test_cpu_count_2(self):
sys_value = win32api.GetSystemInfo()[5]
psutil_value = psutil.cpu_count()
self.assertEqual(sys_value, psutil_value)
def test_cpu_freq(self):
w = wmi.WMI()
proc = w.Win32_Processor()[0]
self.assertEqual(proc.CurrentClockSpeed, psutil.cpu_freq().current)
self.assertEqual(proc.MaxClockSpeed, psutil.cpu_freq().max)
def test_total_phymem(self):
w = wmi.WMI().Win32_ComputerSystem()[0]
self.assertEqual(int(w.TotalPhysicalMemory),
psutil.virtual_memory().total)
# @unittest.skipIf(wmi is None, "wmi module is not installed")
# def test__UPTIME(self):
# # _UPTIME constant is not public but it is used internally
# # as value to return for pid 0 creation time.
# # WMI behaves the same.
# w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
# p = psutil.Process(0)
# wmic_create = str(w.CreationDate.split('.')[0])
# psutil_create = time.strftime("%Y%m%d%H%M%S",
# time.localtime(p.create_time()))
# Note: this test is not very reliable
@unittest.skipIf(APPVEYOR, "test not relieable on appveyor")
@retry_before_failing()
def test_pids(self):
# Note: this test might fail if the OS is starting/killing
# other processes in the meantime
w = wmi.WMI().Win32_Process()
wmi_pids = set([x.ProcessId for x in w])
psutil_pids = set(psutil.pids())
self.assertEqual(wmi_pids, psutil_pids)
@retry_before_failing()
def test_disks(self):
ps_parts = psutil.disk_partitions(all=True)
wmi_parts = wmi.WMI().Win32_LogicalDisk()
for ps_part in ps_parts:
for wmi_part in wmi_parts:
if ps_part.device.replace('\\', '') == wmi_part.DeviceID:
if not ps_part.mountpoint:
# this is usually a CD-ROM with no disk inserted
break
try:
usage = psutil.disk_usage(ps_part.mountpoint)
except OSError as err:
if err.errno == errno.ENOENT:
# usually this is the floppy
break
else:
raise
self.assertEqual(usage.total, int(wmi_part.Size))
wmi_free = int(wmi_part.FreeSpace)
self.assertEqual(usage.free, wmi_free)
# 10 MB tollerance
if abs(usage.free - wmi_free) > 10 * 1024 * 1024:
self.fail("psutil=%s, wmi=%s" % (
usage.free, wmi_free))
break
else:
self.fail("can't find partition %s" % repr(ps_part))
def test_disk_usage(self):
for disk in psutil.disk_partitions():
sys_value = win32api.GetDiskFreeSpaceEx(disk.mountpoint)
psutil_value = psutil.disk_usage(disk.mountpoint)
self.assertAlmostEqual(sys_value[0], psutil_value.free,
delta=1024 * 1024)
self.assertAlmostEqual(sys_value[1], psutil_value.total,
delta=1024 * 1024)
self.assertEqual(psutil_value.used,
psutil_value.total - psutil_value.free)
def test_disk_partitions(self):
sys_value = [
x + '\\' for x in win32api.GetLogicalDriveStrings().split("\\\x00")
if x and not x.startswith('A:')]
psutil_value = [x.mountpoint for x in psutil.disk_partitions(all=True)]
self.assertEqual(sys_value, psutil_value)
def test_net_if_stats(self):
ps_names = set(cext.net_if_stats())
wmi_adapters = wmi.WMI().Win32_NetworkAdapter()
wmi_names = set()
for wmi_adapter in wmi_adapters:
wmi_names.add(wmi_adapter.Name)
wmi_names.add(wmi_adapter.NetConnectionID)
self.assertTrue(ps_names & wmi_names,
"no common entries in %s, %s" % (ps_names, wmi_names))
def test_boot_time(self):
wmi_os = wmi.WMI().Win32_OperatingSystem()
wmi_btime_str = wmi_os[0].LastBootUpTime.split('.')[0]
wmi_btime_dt = datetime.datetime.strptime(
wmi_btime_str, "%Y%m%d%H%M%S")
psutil_dt = datetime.datetime.fromtimestamp(psutil.boot_time())
diff = abs((wmi_btime_dt - psutil_dt).total_seconds())
# Wmic time is 2-3 secs lower for some reason; that's OK.
self.assertLessEqual(diff, 3)
def test_boot_time_fluctuation(self):
# https://github.com/giampaolo/psutil/issues/1007
with mock.patch('psutil._pswindows.cext.boot_time', return_value=5):
self.assertEqual(psutil.boot_time(), 5)
with mock.patch('psutil._pswindows.cext.boot_time', return_value=4):
self.assertEqual(psutil.boot_time(), 5)
with mock.patch('psutil._pswindows.cext.boot_time', return_value=6):
self.assertEqual(psutil.boot_time(), 5)
with mock.patch('psutil._pswindows.cext.boot_time', return_value=333):
self.assertEqual(psutil.boot_time(), 333)
# ===================================================================
# sensors_battery()
# ===================================================================
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class TestSensorsBattery(unittest.TestCase):
def test_has_battery(self):
if win32api.GetPwrCapabilities()['SystemBatteriesPresent']:
self.assertIsNotNone(psutil.sensors_battery())
else:
self.assertIsNone(psutil.sensors_battery())
@unittest.skipIf(not HAS_BATTERY, "no battery")
def test_percent(self):
w = wmi.WMI()
battery_wmi = w.query('select * from Win32_Battery')[0]
battery_psutil = psutil.sensors_battery()
self.assertAlmostEqual(
battery_psutil.percent, battery_wmi.EstimatedChargeRemaining,
delta=1)
@unittest.skipIf(not HAS_BATTERY, "no battery")
def test_power_plugged(self):
w = wmi.WMI()
battery_wmi = w.query('select * from Win32_Battery')[0]
battery_psutil = psutil.sensors_battery()
# Status codes:
# https://msdn.microsoft.com/en-us/library/aa394074(v=vs.85).aspx
self.assertEqual(battery_psutil.power_plugged,
battery_wmi.BatteryStatus == 2)
def test_emulate_no_battery(self):
with mock.patch("psutil._pswindows.cext.sensors_battery",
return_value=(0, 128, 0, 0)) as m:
self.assertIsNone(psutil.sensors_battery())
assert m.called
def test_emulate_power_connected(self):
with mock.patch("psutil._pswindows.cext.sensors_battery",
return_value=(1, 0, 0, 0)) as m:
self.assertEqual(psutil.sensors_battery().secsleft,
psutil.POWER_TIME_UNLIMITED)
assert m.called
def test_emulate_power_charging(self):
with mock.patch("psutil._pswindows.cext.sensors_battery",
return_value=(0, 8, 0, 0)) as m:
self.assertEqual(psutil.sensors_battery().secsleft,
psutil.POWER_TIME_UNLIMITED)
assert m.called
def test_emulate_secs_left_unknown(self):
with mock.patch("psutil._pswindows.cext.sensors_battery",
return_value=(0, 0, 0, -1)) as m:
self.assertEqual(psutil.sensors_battery().secsleft,
psutil.POWER_TIME_UNKNOWN)
assert m.called
# ===================================================================
# Process APIs
# ===================================================================
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class TestProcess(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.pid = get_test_subprocess().pid
@classmethod
def tearDownClass(cls):
reap_children()
def test_issue_24(self):
p = psutil.Process(0)
self.assertRaises(psutil.AccessDenied, p.kill)
def test_special_pid(self):
p = psutil.Process(4)
self.assertEqual(p.name(), 'System')
# use __str__ to access all common Process properties to check
# that nothing strange happens
str(p)
p.username()
self.assertTrue(p.create_time() >= 0.0)
try:
rss, vms = p.memory_info()[:2]
except psutil.AccessDenied:
# expected on Windows Vista and Windows 7
if not platform.uname()[1] in ('vista', 'win-7', 'win7'):
raise
else:
self.assertTrue(rss > 0)
def test_send_signal(self):
p = psutil.Process(self.pid)
self.assertRaises(ValueError, p.send_signal, signal.SIGINT)
def test_exe(self):
for p in psutil.process_iter():
try:
self.assertEqual(os.path.basename(p.exe()), p.name())
except psutil.Error:
pass
def test_num_handles_increment(self):
p = psutil.Process(os.getpid())
before = p.num_handles()
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
win32con.FALSE, os.getpid())
after = p.num_handles()
self.assertEqual(after, before + 1)
win32api.CloseHandle(handle)
self.assertEqual(p.num_handles(), before)
def test_handles_leak(self):
# Call all Process methods and make sure no handles are left
# open. This is here mainly to make sure functions using
# OpenProcess() always call CloseHandle().
def call(p, attr):
attr = getattr(p, name, None)
if attr is not None and callable(attr):
attr()
else:
attr
p = psutil.Process(self.pid)
failures = []
for name in dir(psutil.Process):
if name.startswith('_') \
or name in ('terminate', 'kill', 'suspend', 'resume',
'nice', 'send_signal', 'wait', 'children',
'as_dict', 'memory_info_ex'):
continue
else:
try:
call(p, name)
num1 = p.num_handles()
call(p, name)
num2 = p.num_handles()
except (psutil.NoSuchProcess, psutil.AccessDenied):
pass
else:
if num2 > num1:
fail = \
"failure while processing Process.%s method " \
"(before=%s, after=%s)" % (name, num1, num2)
failures.append(fail)
if failures:
self.fail('\n' + '\n'.join(failures))
def test_name_always_available(self):
# On Windows name() is never supposed to raise AccessDenied,
# see https://github.com/giampaolo/psutil/issues/627
for p in psutil.process_iter():
try:
p.name()
except psutil.NoSuchProcess:
pass
@unittest.skipIf(not sys.version_info >= (2, 7),
"CTRL_* signals not supported")
def test_ctrl_signals(self):
p = psutil.Process(get_test_subprocess().pid)
p.send_signal(signal.CTRL_C_EVENT)
p.send_signal(signal.CTRL_BREAK_EVENT)
p.kill()
p.wait()
self.assertRaises(psutil.NoSuchProcess,
p.send_signal, signal.CTRL_C_EVENT)
self.assertRaises(psutil.NoSuchProcess,
p.send_signal, signal.CTRL_BREAK_EVENT)
def test_compare_name_exe(self):
for p in psutil.process_iter():
try:
a = os.path.basename(p.exe())
b = p.name()
except (psutil.NoSuchProcess, psutil.AccessDenied):
pass
else:
self.assertEqual(a, b)
def test_username(self):
self.assertEqual(psutil.Process().username(),
win32api.GetUserNameEx(win32con.NameSamCompatible))
def test_cmdline(self):
sys_value = re.sub(' +', ' ', win32api.GetCommandLine()).strip()
psutil_value = ' '.join(psutil.Process().cmdline())
self.assertEqual(sys_value, psutil_value)
# XXX - occasional failures
# def test_cpu_times(self):
# handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
# win32con.FALSE, os.getpid())
# self.addCleanup(win32api.CloseHandle, handle)
# sys_value = win32process.GetProcessTimes(handle)
# psutil_value = psutil.Process().cpu_times()
# self.assertAlmostEqual(
# psutil_value.user, sys_value['UserTime'] / 10000000.0,
# delta=0.2)
# self.assertAlmostEqual(
# psutil_value.user, sys_value['KernelTime'] / 10000000.0,
# delta=0.2)
def test_nice(self):
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
win32con.FALSE, os.getpid())
self.addCleanup(win32api.CloseHandle, handle)
sys_value = win32process.GetPriorityClass(handle)
psutil_value = psutil.Process().nice()
self.assertEqual(psutil_value, sys_value)
def test_memory_info(self):
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
win32con.FALSE, self.pid)
self.addCleanup(win32api.CloseHandle, handle)
sys_value = win32process.GetProcessMemoryInfo(handle)
psutil_value = psutil.Process(self.pid).memory_info()
self.assertEqual(
sys_value['PeakWorkingSetSize'], psutil_value.peak_wset)
self.assertEqual(
sys_value['WorkingSetSize'], psutil_value.wset)
self.assertEqual(
sys_value['QuotaPeakPagedPoolUsage'], psutil_value.peak_paged_pool)
self.assertEqual(
sys_value['QuotaPagedPoolUsage'], psutil_value.paged_pool)
self.assertEqual(
sys_value['QuotaPeakNonPagedPoolUsage'],
psutil_value.peak_nonpaged_pool)
self.assertEqual(
sys_value['QuotaNonPagedPoolUsage'], psutil_value.nonpaged_pool)
self.assertEqual(
sys_value['PagefileUsage'], psutil_value.pagefile)
self.assertEqual(
sys_value['PeakPagefileUsage'], psutil_value.peak_pagefile)
self.assertEqual(psutil_value.rss, psutil_value.wset)
self.assertEqual(psutil_value.vms, psutil_value.pagefile)
def test_wait(self):
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
win32con.FALSE, self.pid)
self.addCleanup(win32api.CloseHandle, handle)
p = psutil.Process(self.pid)
p.terminate()
psutil_value = p.wait()
sys_value = win32process.GetExitCodeProcess(handle)
self.assertEqual(psutil_value, sys_value)
def test_cpu_affinity(self):
def from_bitmask(x):
return [i for i in range(64) if (1 << i) & x]
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
win32con.FALSE, self.pid)
self.addCleanup(win32api.CloseHandle, handle)
sys_value = from_bitmask(
win32process.GetProcessAffinityMask(handle)[0])
psutil_value = psutil.Process(self.pid).cpu_affinity()
self.assertEqual(psutil_value, sys_value)
def test_io_counters(self):
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
win32con.FALSE, os.getpid())
self.addCleanup(win32api.CloseHandle, handle)
sys_value = win32process.GetProcessIoCounters(handle)
psutil_value = psutil.Process().io_counters()
self.assertEqual(
psutil_value.read_count, sys_value['ReadOperationCount'])
self.assertEqual(
psutil_value.write_count, sys_value['WriteOperationCount'])
self.assertEqual(
psutil_value.read_bytes, sys_value['ReadTransferCount'])
self.assertEqual(
psutil_value.write_bytes, sys_value['WriteTransferCount'])
self.assertEqual(
psutil_value.other_count, sys_value['OtherOperationCount'])
self.assertEqual(
psutil_value.other_bytes, sys_value['OtherTransferCount'])
def test_num_handles(self):
import ctypes
import ctypes.wintypes
PROCESS_QUERY_INFORMATION = 0x400
handle = ctypes.windll.kernel32.OpenProcess(
PROCESS_QUERY_INFORMATION, 0, os.getpid())
self.addCleanup(ctypes.windll.kernel32.CloseHandle, handle)
hndcnt = ctypes.wintypes.DWORD()
ctypes.windll.kernel32.GetProcessHandleCount(
handle, ctypes.byref(hndcnt))
sys_value = hndcnt.value
psutil_value = psutil.Process().num_handles()
ctypes.windll.kernel32.CloseHandle(handle)
self.assertEqual(psutil_value, sys_value + 1)
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class TestProcessWMI(unittest.TestCase):
"""Compare Process API results with WMI."""
@classmethod
def setUpClass(cls):
cls.pid = get_test_subprocess().pid
@classmethod
def tearDownClass(cls):
reap_children()
def test_name(self):
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
p = psutil.Process(self.pid)
self.assertEqual(p.name(), w.Caption)
def test_exe(self):
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
p = psutil.Process(self.pid)
# Note: wmi reports the exe as a lower case string.
# Being Windows paths case-insensitive we ignore that.
self.assertEqual(p.exe().lower(), w.ExecutablePath.lower())
def test_cmdline(self):
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
p = psutil.Process(self.pid)
self.assertEqual(' '.join(p.cmdline()),
w.CommandLine.replace('"', ''))
def test_username(self):
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
p = psutil.Process(self.pid)
domain, _, username = w.GetOwner()
username = "%s\\%s" % (domain, username)
self.assertEqual(p.username(), username)
def test_memory_rss(self):
time.sleep(0.1)
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
p = psutil.Process(self.pid)
rss = p.memory_info().rss
self.assertEqual(rss, int(w.WorkingSetSize))
def test_memory_vms(self):
time.sleep(0.1)
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
p = psutil.Process(self.pid)
vms = p.memory_info().vms
# http://msdn.microsoft.com/en-us/library/aa394372(VS.85).aspx
# ...claims that PageFileUsage is represented in Kilo
# bytes but funnily enough on certain platforms bytes are
# returned instead.
wmi_usage = int(w.PageFileUsage)
if (vms != wmi_usage) and (vms != wmi_usage * 1024):
self.fail("wmi=%s, psutil=%s" % (wmi_usage, vms))
def test_create_time(self):
w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
p = psutil.Process(self.pid)
wmic_create = str(w.CreationDate.split('.')[0])
psutil_create = time.strftime("%Y%m%d%H%M%S",
time.localtime(p.create_time()))
self.assertEqual(wmic_create, psutil_create)
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class TestDualProcessImplementation(unittest.TestCase):
"""
Certain APIs on Windows have 2 internal implementations, one
based on documented Windows APIs, another one based
NtQuerySystemInformation() which gets called as fallback in
case the first fails because of limited permission error.
Here we test that the two methods return the exact same value,
see:
https://github.com/giampaolo/psutil/issues/304
"""
@classmethod
def setUpClass(cls):
cls.pid = get_test_subprocess().pid
@classmethod
def tearDownClass(cls):
reap_children()
# ---
# same tests as above but mimicks the AccessDenied failure of
# the first (fast) method failing with AD.
def test_name(self):
name = psutil.Process(self.pid).name()
with mock.patch("psutil._psplatform.cext.proc_exe",
side_effect=psutil.AccessDenied(os.getpid())) as fun:
self.assertEqual(psutil.Process(self.pid).name(), name)
assert fun.called
def test_memory_info(self):
mem_1 = psutil.Process(self.pid).memory_info()
with mock.patch("psutil._psplatform.cext.proc_memory_info",
side_effect=OSError(errno.EPERM, "msg")) as fun:
mem_2 = psutil.Process(self.pid).memory_info()
self.assertEqual(len(mem_1), len(mem_2))
for i in range(len(mem_1)):
self.assertGreaterEqual(mem_1[i], 0)
self.assertGreaterEqual(mem_2[i], 0)
self.assertAlmostEqual(mem_1[i], mem_2[i], delta=512)
assert fun.called
def test_create_time(self):
ctime = psutil.Process(self.pid).create_time()
with mock.patch("psutil._psplatform.cext.proc_create_time",
side_effect=OSError(errno.EPERM, "msg")) as fun:
self.assertEqual(psutil.Process(self.pid).create_time(), ctime)
assert fun.called
def test_cpu_times(self):
cpu_times_1 = psutil.Process(self.pid).cpu_times()
with mock.patch("psutil._psplatform.cext.proc_cpu_times",
side_effect=OSError(errno.EPERM, "msg")) as fun:
cpu_times_2 = psutil.Process(self.pid).cpu_times()
assert fun.called
self.assertAlmostEqual(
cpu_times_1.user, cpu_times_2.user, delta=0.01)
self.assertAlmostEqual(
cpu_times_1.system, cpu_times_2.system, delta=0.01)
def test_io_counters(self):
io_counters_1 = psutil.Process(self.pid).io_counters()
with mock.patch("psutil._psplatform.cext.proc_io_counters",
side_effect=OSError(errno.EPERM, "msg")) as fun:
io_counters_2 = psutil.Process(self.pid).io_counters()
for i in range(len(io_counters_1)):
self.assertAlmostEqual(
io_counters_1[i], io_counters_2[i], delta=5)
assert fun.called
def test_num_handles(self):
num_handles = psutil.Process(self.pid).num_handles()
with mock.patch("psutil._psplatform.cext.proc_num_handles",
side_effect=OSError(errno.EPERM, "msg")) as fun:
self.assertEqual(psutil.Process(self.pid).num_handles(),
num_handles)
assert fun.called
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class RemoteProcessTestCase(unittest.TestCase):
"""Certain functions require calling ReadProcessMemory.
This trivially works when called on the current process.
Check that this works on other processes, especially when they
have a different bitness.
"""
@staticmethod
def find_other_interpreter():
# find a python interpreter that is of the opposite bitness from us
code = "import sys; sys.stdout.write(str(sys.maxsize > 2**32))"
# XXX: a different and probably more stable approach might be to access
# the registry but accessing 64 bit paths from a 32 bit process
for filename in glob.glob(r"C:\Python*\python.exe"):
proc = subprocess.Popen(args=[filename, "-c", code],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, _ = proc.communicate()
if output == str(not IS_64_BIT):
return filename
@classmethod
def setUpClass(cls):
other_python = cls.find_other_interpreter()
if other_python is None:
raise unittest.SkipTest(
"could not find interpreter with opposite bitness")
if IS_64_BIT:
cls.python64 = sys.executable
cls.python32 = other_python
else:
cls.python64 = other_python
cls.python32 = sys.executable
test_args = ["-c", "import sys; sys.stdin.read()"]
def setUp(self):
env = os.environ.copy()
env["THINK_OF_A_NUMBER"] = str(os.getpid())
self.proc32 = get_test_subprocess([self.python32] + self.test_args,
env=env,
stdin=subprocess.PIPE)
self.proc64 = get_test_subprocess([self.python64] + self.test_args,
env=env,
stdin=subprocess.PIPE)
def tearDown(self):
self.proc32.communicate()
self.proc64.communicate()
reap_children()
@classmethod
def tearDownClass(cls):
reap_children()
def test_cmdline_32(self):
p = psutil.Process(self.proc32.pid)
self.assertEqual(len(p.cmdline()), 3)
self.assertEqual(p.cmdline()[1:], self.test_args)
def test_cmdline_64(self):
p = psutil.Process(self.proc64.pid)
self.assertEqual(len(p.cmdline()), 3)
self.assertEqual(p.cmdline()[1:], self.test_args)
def test_cwd_32(self):
p = psutil.Process(self.proc32.pid)
self.assertEqual(p.cwd(), os.getcwd())
def test_cwd_64(self):
p = psutil.Process(self.proc64.pid)
self.assertEqual(p.cwd(), os.getcwd())
def test_environ_32(self):
p = psutil.Process(self.proc32.pid)
e = p.environ()
self.assertIn("THINK_OF_A_NUMBER", e)
self.assertEquals(e["THINK_OF_A_NUMBER"], str(os.getpid()))
def test_environ_64(self):
p = psutil.Process(self.proc64.pid)
e = p.environ()
self.assertIn("THINK_OF_A_NUMBER", e)
self.assertEquals(e["THINK_OF_A_NUMBER"], str(os.getpid()))
# ===================================================================
# Windows services
# ===================================================================
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class TestServices(unittest.TestCase):
def test_win_service_iter(self):
valid_statuses = set([
"running",
"paused",
"start",
"pause",
"continue",
"stop",
"stopped",
])
valid_start_types = set([
"automatic",
"manual",
"disabled",
])
valid_statuses = set([
"running",
"paused",
"start_pending",
"pause_pending",
"continue_pending",
"stop_pending",
"stopped"
])
for serv in psutil.win_service_iter():
data = serv.as_dict()
self.assertIsInstance(data['name'], str)
self.assertNotEqual(data['name'].strip(), "")
self.assertIsInstance(data['display_name'], str)
self.assertIsInstance(data['username'], str)
self.assertIn(data['status'], valid_statuses)
if data['pid'] is not None:
psutil.Process(data['pid'])
self.assertIsInstance(data['binpath'], str)
self.assertIsInstance(data['username'], str)
self.assertIsInstance(data['start_type'], str)
self.assertIn(data['start_type'], valid_start_types)
self.assertIn(data['status'], valid_statuses)
self.assertIsInstance(data['description'], str)
pid = serv.pid()
if pid is not None:
p = psutil.Process(pid)
self.assertTrue(p.is_running())
# win_service_get
s = psutil.win_service_get(serv.name())
# test __eq__
self.assertEqual(serv, s)
def test_win_service_get(self):
name = next(psutil.win_service_iter()).name()
with self.assertRaises(psutil.NoSuchProcess) as cm:
psutil.win_service_get(name + '???')
self.assertEqual(cm.exception.name, name + '???')
# test NoSuchProcess
service = psutil.win_service_get(name)
exc = WindowsError(
psutil._psplatform.cext.ERROR_SERVICE_DOES_NOT_EXIST, "")
with mock.patch("psutil._psplatform.cext.winservice_query_status",
side_effect=exc):
self.assertRaises(psutil.NoSuchProcess, service.status)
with mock.patch("psutil._psplatform.cext.winservice_query_config",
side_effect=exc):
self.assertRaises(psutil.NoSuchProcess, service.username)
# test AccessDenied
exc = WindowsError(
psutil._psplatform.cext.ERROR_ACCESS_DENIED, "")
with mock.patch("psutil._psplatform.cext.winservice_query_status",
side_effect=exc):
self.assertRaises(psutil.AccessDenied, service.status)
with mock.patch("psutil._psplatform.cext.winservice_query_config",
side_effect=exc):
self.assertRaises(psutil.AccessDenied, service.username)
# test __str__ and __repr__
self.assertIn(service.name(), str(service))
self.assertIn(service.display_name(), str(service))
self.assertIn(service.name(), repr(service))
self.assertIn(service.display_name(), repr(service))
if __name__ == '__main__':
run_test_module_by_name(__file__)
PK ! [2 [2 test_unicode.pynu [ # -*- coding: utf-8 -*-
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
Notes about unicode handling in psutil
======================================
In psutil these are the APIs returning or dealing with a string
('not tested' means they are not tested to deal with non-ASCII strings):
* Process.cmdline()
* Process.connections('unix')
* Process.cwd()
* Process.environ()
* Process.exe()
* Process.memory_maps()
* Process.name()
* Process.open_files()
* Process.username() (not tested)
* disk_io_counters() (not tested)
* disk_partitions() (not tested)
* disk_usage(str)
* net_connections('unix')
* net_if_addrs() (not tested)
* net_if_stats() (not tested)
* net_io_counters() (not tested)
* sensors_fans() (not tested)
* sensors_temperatures() (not tested)
* users() (not tested)
* WindowsService.binpath() (not tested)
* WindowsService.description() (not tested)
* WindowsService.display_name() (not tested)
* WindowsService.name() (not tested)
* WindowsService.status() (not tested)
* WindowsService.username() (not tested)
In here we create a unicode path with a funky non-ASCII name and (where
possible) make psutil return it back (e.g. on name(), exe(), open_files(),
etc.) and make sure that:
* psutil never crashes with UnicodeDecodeError
* the returned path matches
For a detailed explanation of how psutil handles unicode see:
- https://github.com/giampaolo/psutil/issues/1040
- http://psutil.readthedocs.io/#unicode
"""
import os
import traceback
import warnings
from contextlib import closing
from psutil import BSD
from psutil import OPENBSD
from psutil import OSX
from psutil import POSIX
from psutil import WINDOWS
from psutil._compat import PY3
from psutil._compat import u
from psutil.tests import APPVEYOR
from psutil.tests import ASCII_FS
from psutil.tests import bind_unix_socket
from psutil.tests import chdir
from psutil.tests import copyload_shared_lib
from psutil.tests import create_exe
from psutil.tests import get_test_subprocess
from psutil.tests import HAS_CONNECTIONS_UNIX
from psutil.tests import HAS_ENVIRON
from psutil.tests import HAS_MEMORY_MAPS
from psutil.tests import mock
from psutil.tests import reap_children
from psutil.tests import run_test_module_by_name
from psutil.tests import safe_mkdir
from psutil.tests import safe_rmpath as _safe_rmpath
from psutil.tests import skip_on_access_denied
from psutil.tests import TESTFILE_PREFIX
from psutil.tests import TESTFN
from psutil.tests import TESTFN_UNICODE
from psutil.tests import TRAVIS
from psutil.tests import unittest
from psutil.tests import unix_socket_path
import psutil
import psutil.tests
def safe_rmpath(path):
if APPVEYOR:
# TODO - this is quite random and I'm not sure why it happens,
# nor I can reproduce it locally:
# https://ci.appveyor.com/project/giampaolo/psutil/build/job/
# jiq2cgd6stsbtn60
# safe_rmpath() happens after reap_children() so this is weird
# Perhaps wait_procs() on Windows is broken? Maybe because
# of STILL_ACTIVE?
# https://github.com/giampaolo/psutil/blob/
# 68c7a70728a31d8b8b58f4be6c4c0baa2f449eda/psutil/arch/
# windows/process_info.c#L146
try:
return _safe_rmpath(path)
except WindowsError:
traceback.print_exc()
else:
return _safe_rmpath(path)
def subprocess_supports_unicode(name):
"""Return True if both the fs and the subprocess module can
deal with a unicode file name.
"""
if PY3:
return True
try:
safe_rmpath(name)
create_exe(name)
get_test_subprocess(cmd=[name])
except UnicodeEncodeError:
return False
else:
return True
finally:
reap_children()
# An invalid unicode string.
if PY3:
INVALID_NAME = (TESTFN.encode('utf8') + b"f\xc0\x80").decode(
'utf8', 'surrogateescape')
else:
INVALID_NAME = TESTFN + "f\xc0\x80"
# ===================================================================
# FS APIs
# ===================================================================
class _BaseFSAPIsTests(object):
funky_name = None
@classmethod
def setUpClass(cls):
safe_rmpath(cls.funky_name)
create_exe(cls.funky_name)
@classmethod
def tearDownClass(cls):
reap_children()
safe_rmpath(cls.funky_name)
def tearDown(self):
reap_children()
def expect_exact_path_match(self):
raise NotImplementedError("must be implemented in subclass")
def test_proc_exe(self):
subp = get_test_subprocess(cmd=[self.funky_name])
p = psutil.Process(subp.pid)
exe = p.exe()
self.assertIsInstance(exe, str)
if self.expect_exact_path_match():
self.assertEqual(exe, self.funky_name)
def test_proc_name(self):
subp = get_test_subprocess(cmd=[self.funky_name])
if WINDOWS:
# On Windows name() is determined from exe() first, because
# it's faster; we want to overcome the internal optimization
# and test name() instead of exe().
with mock.patch("psutil._psplatform.cext.proc_exe",
side_effect=psutil.AccessDenied(os.getpid())) as m:
name = psutil.Process(subp.pid).name()
assert m.called
else:
name = psutil.Process(subp.pid).name()
self.assertIsInstance(name, str)
if self.expect_exact_path_match():
self.assertEqual(name, os.path.basename(self.funky_name))
def test_proc_cmdline(self):
subp = get_test_subprocess(cmd=[self.funky_name])
p = psutil.Process(subp.pid)
cmdline = p.cmdline()
for part in cmdline:
self.assertIsInstance(part, str)
if self.expect_exact_path_match():
self.assertEqual(cmdline, [self.funky_name])
def test_proc_cwd(self):
dname = self.funky_name + "2"
self.addCleanup(safe_rmpath, dname)
safe_mkdir(dname)
with chdir(dname):
p = psutil.Process()
cwd = p.cwd()
self.assertIsInstance(p.cwd(), str)
if self.expect_exact_path_match():
self.assertEqual(cwd, dname)
def test_proc_open_files(self):
p = psutil.Process()
start = set(p.open_files())
with open(self.funky_name, 'rb'):
new = set(p.open_files())
path = (new - start).pop().path
self.assertIsInstance(path, str)
if BSD and not path:
# XXX - see https://github.com/giampaolo/psutil/issues/595
return self.skipTest("open_files on BSD is broken")
if self.expect_exact_path_match():
self.assertEqual(os.path.normcase(path),
os.path.normcase(self.funky_name))
@unittest.skipIf(not POSIX, "POSIX only")
def test_proc_connections(self):
suffix = os.path.basename(self.funky_name)
with unix_socket_path(suffix=suffix) as name:
try:
sock = bind_unix_socket(name)
except UnicodeEncodeError:
if PY3:
raise
else:
raise unittest.SkipTest("not supported")
with closing(sock):
conn = psutil.Process().connections('unix')[0]
self.assertIsInstance(conn.laddr, str)
# AF_UNIX addr not set on OpenBSD
if not OPENBSD:
self.assertEqual(conn.laddr, name)
@unittest.skipIf(not POSIX, "POSIX only")
@unittest.skipIf(not HAS_CONNECTIONS_UNIX, "can't list UNIX sockets")
@skip_on_access_denied()
def test_net_connections(self):
def find_sock(cons):
for conn in cons:
if os.path.basename(conn.laddr).startswith(TESTFILE_PREFIX):
return conn
raise ValueError("connection not found")
suffix = os.path.basename(self.funky_name)
with unix_socket_path(suffix=suffix) as name:
try:
sock = bind_unix_socket(name)
except UnicodeEncodeError:
if PY3:
raise
else:
raise unittest.SkipTest("not supported")
with closing(sock):
cons = psutil.net_connections(kind='unix')
# AF_UNIX addr not set on OpenBSD
if not OPENBSD:
conn = find_sock(cons)
self.assertIsInstance(conn.laddr, str)
self.assertEqual(conn.laddr, name)
def test_disk_usage(self):
dname = self.funky_name + "2"
self.addCleanup(safe_rmpath, dname)
safe_mkdir(dname)
psutil.disk_usage(dname)
@unittest.skipIf(not HAS_MEMORY_MAPS, "not supported")
@unittest.skipIf(not PY3, "ctypes does not support unicode on PY2")
def test_memory_maps(self):
# XXX: on Python 2, using ctypes.CDLL with a unicode path
# opens a message box which blocks the test run.
with copyload_shared_lib(dst_prefix=self.funky_name) as funky_path:
def normpath(p):
return os.path.realpath(os.path.normcase(p))
libpaths = [normpath(x.path)
for x in psutil.Process().memory_maps()]
# ...just to have a clearer msg in case of failure
libpaths = [x for x in libpaths if TESTFILE_PREFIX in x]
self.assertIn(normpath(funky_path), libpaths)
for path in libpaths:
self.assertIsInstance(path, str)
@unittest.skipIf(OSX and TRAVIS, "unreliable on TRAVIS") # TODO
@unittest.skipIf(ASCII_FS, "ASCII fs")
@unittest.skipIf(not subprocess_supports_unicode(TESTFN_UNICODE),
"subprocess can't deal with unicode")
class TestFSAPIs(_BaseFSAPIsTests, unittest.TestCase):
"""Test FS APIs with a funky, valid, UTF8 path name."""
funky_name = TESTFN_UNICODE
@classmethod
def expect_exact_path_match(cls):
# Do not expect psutil to correctly handle unicode paths on
# Python 2 if os.listdir() is not able either.
if PY3:
return True
else:
here = '.' if isinstance(cls.funky_name, str) else u('.')
with warnings.catch_warnings():
warnings.simplefilter("ignore")
return cls.funky_name in os.listdir(here)
@unittest.skipIf(OSX and TRAVIS, "unreliable on TRAVIS") # TODO
@unittest.skipIf(not subprocess_supports_unicode(INVALID_NAME),
"subprocess can't deal with invalid unicode")
class TestFSAPIsWithInvalidPath(_BaseFSAPIsTests, unittest.TestCase):
"""Test FS APIs with a funky, invalid path name."""
funky_name = INVALID_NAME
@classmethod
def expect_exact_path_match(cls):
# Invalid unicode names are supposed to work on Python 2.
return True
@unittest.skipIf(not WINDOWS, "WINDOWS only")
class TestWinProcessName(unittest.TestCase):
def test_name_type(self):
# On Windows name() is determined from exe() first, because
# it's faster; we want to overcome the internal optimization
# and test name() instead of exe().
with mock.patch("psutil._psplatform.cext.proc_exe",
side_effect=psutil.AccessDenied(os.getpid())) as m:
self.assertIsInstance(psutil.Process().name(), str)
assert m.called
# ===================================================================
# Non fs APIs
# ===================================================================
class TestNonFSAPIS(unittest.TestCase):
"""Unicode tests for non fs-related APIs."""
def tearDown(self):
reap_children()
@unittest.skipIf(not HAS_ENVIRON, "not supported")
def test_proc_environ(self):
# Note: differently from others, this test does not deal
# with fs paths. On Python 2 subprocess module is broken as
# it's not able to handle with non-ASCII env vars, so
# we use "è", which is part of the extended ASCII table
# (unicode point <= 255).
env = os.environ.copy()
funky_str = TESTFN_UNICODE if PY3 else 'è'
env['FUNNY_ARG'] = funky_str
sproc = get_test_subprocess(env=env)
p = psutil.Process(sproc.pid)
env = p.environ()
for k, v in env.items():
self.assertIsInstance(k, str)
self.assertIsInstance(v, str)
self.assertEqual(env['FUNNY_ARG'], funky_str)
if __name__ == '__main__':
run_test_module_by_name(__file__)
PK ! XAm m test_aix.pynu [
# Copyright (c) 2009, Giampaolo Rodola'
# Copyright (c) 2017, Arnon Yaari
# All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""AIX specific tests."""
import re
from psutil import AIX
from psutil.tests import run_test_module_by_name
from psutil.tests import sh
from psutil.tests import unittest
import psutil
@unittest.skipIf(not AIX, "AIX only")
class AIXSpecificTestCase(unittest.TestCase):
def test_virtual_memory(self):
out = sh('/usr/bin/svmon -O unit=KB')
re_pattern = "memory\s*"
for field in ("size inuse free pin virtual available mmode").split():
re_pattern += "(?P<%s>\S+)\s+" % (field,)
matchobj = re.search(re_pattern, out)
self.assertIsNotNone(
matchobj, "svmon command returned unexpected output")
KB = 1024
total = int(matchobj.group("size")) * KB
available = int(matchobj.group("available")) * KB
used = int(matchobj.group("inuse")) * KB
free = int(matchobj.group("free")) * KB
psutil_result = psutil.virtual_memory()
# MEMORY_TOLERANCE from psutil.tests is not enough. For some reason
# we're seeing differences of ~1.2 MB. 2 MB is still a good tolerance
# when compared to GBs.
MEMORY_TOLERANCE = 2 * KB * KB # 2 MB
self.assertEqual(psutil_result.total, total)
self.assertAlmostEqual(
psutil_result.used, used, delta=MEMORY_TOLERANCE)
self.assertAlmostEqual(
psutil_result.available, available, delta=MEMORY_TOLERANCE)
self.assertAlmostEqual(
psutil_result.free, free, delta=MEMORY_TOLERANCE)
def test_swap_memory(self):
out = sh('/usr/sbin/lsps -a')
# From the man page, "The size is given in megabytes" so we assume
# we'll always have 'MB' in the result
# TODO maybe try to use "swap -l" to check "used" too, but its units
# are not guaranteed to be "MB" so parsing may not be consistent
matchobj = re.search("(?P\S+)\s+"
"(?P\S+)\s+"
"(?P\S+)\s+"
"(?P\d+)MB", out)
self.assertIsNotNone(
matchobj, "lsps command returned unexpected output")
total_mb = int(matchobj.group("size"))
MB = 1024 ** 2
psutil_result = psutil.swap_memory()
# we divide our result by MB instead of multiplying the lsps value by
# MB because lsps may round down, so we round down too
self.assertEqual(int(psutil_result.total / MB), total_mb)
def test_cpu_stats(self):
out = sh('/usr/bin/mpstat -a')
re_pattern = "ALL\s*"
for field in ("min maj mpcs mpcr dev soft dec ph cs ics bound rq "
"push S3pull S3grd S0rd S1rd S2rd S3rd S4rd S5rd "
"sysc").split():
re_pattern += "(?P<%s>\S+)\s+" % (field,)
matchobj = re.search(re_pattern, out)
self.assertIsNotNone(
matchobj, "mpstat command returned unexpected output")
# numbers are usually in the millions so 1000 is ok for tolerance
CPU_STATS_TOLERANCE = 1000
psutil_result = psutil.cpu_stats()
self.assertAlmostEqual(
psutil_result.ctx_switches,
int(matchobj.group("cs")),
delta=CPU_STATS_TOLERANCE)
self.assertAlmostEqual(
psutil_result.syscalls,
int(matchobj.group("sysc")),
delta=CPU_STATS_TOLERANCE)
self.assertAlmostEqual(
psutil_result.interrupts,
int(matchobj.group("dev")),
delta=CPU_STATS_TOLERANCE)
self.assertAlmostEqual(
psutil_result.soft_interrupts,
int(matchobj.group("soft")),
delta=CPU_STATS_TOLERANCE)
def test_cpu_count_logical(self):
out = sh('/usr/bin/mpstat -a')
mpstat_lcpu = int(re.search("lcpu=(\d+)", out).group(1))
psutil_lcpu = psutil.cpu_count(logical=True)
self.assertEqual(mpstat_lcpu, psutil_lcpu)
def test_net_if_addrs_names(self):
out = sh('/etc/ifconfig -l')
ifconfig_names = set(out.split())
psutil_names = set(psutil.net_if_addrs().keys())
self.assertSetEqual(ifconfig_names, psutil_names)
if __name__ == '__main__':
run_test_module_by_name(__file__)
PK ! ,g
__main__.pynu [
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
Run unit tests. This is invoked by:
$ python -m psutil.tests
"""
import contextlib
import optparse
import os
import ssl
import sys
import tempfile
try:
from urllib.request import urlopen # py3
except ImportError:
from urllib2 import urlopen
from psutil.tests import PYTHON_EXE
from psutil.tests import run_suite
HERE = os.path.abspath(os.path.dirname(__file__))
GET_PIP_URL = "https://bootstrap.pypa.io/get-pip.py"
TEST_DEPS = []
if sys.version_info[:2] == (2, 6):
TEST_DEPS.extend(["ipaddress", "unittest2", "argparse", "mock==1.0.1"])
elif sys.version_info[:2] == (2, 7) or sys.version_info[:2] <= (3, 2):
TEST_DEPS.extend(["ipaddress", "mock"])
elif sys.version_info[:2] == (3, 3):
TEST_DEPS.extend(["ipaddress"])
def install_pip():
try:
import pip # NOQA
except ImportError:
f = tempfile.NamedTemporaryFile(suffix='.py')
with contextlib.closing(f):
print("downloading %s to %s" % (GET_PIP_URL, f.name))
if hasattr(ssl, '_create_unverified_context'):
ctx = ssl._create_unverified_context()
else:
ctx = None
kwargs = dict(context=ctx) if ctx else {}
req = urlopen(GET_PIP_URL, **kwargs)
data = req.read()
f.write(data)
f.flush()
print("installing pip")
code = os.system('%s %s --user' % (PYTHON_EXE, f.name))
return code
def install_test_deps(deps=None):
"""Install test dependencies via pip."""
if deps is None:
deps = TEST_DEPS
deps = set(deps)
if deps:
is_venv = hasattr(sys, 'real_prefix')
opts = "--user" if not is_venv else ""
install_pip()
code = os.system('%s -m pip install %s --upgrade %s' % (
PYTHON_EXE, opts, " ".join(deps)))
return code
def main():
usage = "%s -m psutil.tests [opts]" % PYTHON_EXE
parser = optparse.OptionParser(usage=usage, description="run unit tests")
parser.add_option("-i", "--install-deps",
action="store_true", default=False,
help="don't print status messages to stdout")
opts, args = parser.parse_args()
if opts.install_deps:
install_pip()
install_test_deps()
else:
for dep in TEST_DEPS:
try:
__import__(dep.split("==")[0])
except ImportError:
sys.exit("%r lib is not installed; run %s -m psutil.tests "
"--install-deps" % (dep, PYTHON_EXE))
run_suite()
main()
PK ! 1 3 3
test_linux.pynu [
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Linux specific tests."""
from __future__ import division
import collections
import contextlib
import errno
import glob
import io
import os
import pprint
import re
import shutil
import socket
import struct
import tempfile
import textwrap
import time
import warnings
import psutil
from psutil import LINUX
from psutil._compat import PY3
from psutil._compat import u
from psutil.tests import call_until
from psutil.tests import HAS_BATTERY
from psutil.tests import HAS_CPU_FREQ
from psutil.tests import HAS_RLIMIT
from psutil.tests import MEMORY_TOLERANCE
from psutil.tests import mock
from psutil.tests import PYPY
from psutil.tests import pyrun
from psutil.tests import reap_children
from psutil.tests import reload_module
from psutil.tests import retry_before_failing
from psutil.tests import run_test_module_by_name
from psutil.tests import safe_rmpath
from psutil.tests import sh
from psutil.tests import skip_on_not_implemented
from psutil.tests import TESTFN
from psutil.tests import ThreadTask
from psutil.tests import TRAVIS
from psutil.tests import unittest
from psutil.tests import which
HERE = os.path.abspath(os.path.dirname(__file__))
SIOCGIFADDR = 0x8915
SIOCGIFCONF = 0x8912
SIOCGIFHWADDR = 0x8927
if LINUX:
SECTOR_SIZE = 512
# =====================================================================
# --- utils
# =====================================================================
def get_ipv4_address(ifname):
import fcntl
ifname = ifname[:15]
if PY3:
ifname = bytes(ifname, 'ascii')
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
with contextlib.closing(s):
return socket.inet_ntoa(
fcntl.ioctl(s.fileno(),
SIOCGIFADDR,
struct.pack('256s', ifname))[20:24])
def get_mac_address(ifname):
import fcntl
ifname = ifname[:15]
if PY3:
ifname = bytes(ifname, 'ascii')
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
with contextlib.closing(s):
info = fcntl.ioctl(
s.fileno(), SIOCGIFHWADDR, struct.pack('256s', ifname))
if PY3:
def ord(x):
return x
else:
import __builtin__
ord = __builtin__.ord
return ''.join(['%02x:' % ord(char) for char in info[18:24]])[:-1]
def free_swap():
"""Parse 'free' cmd and return swap memory's s total, used and free
values.
"""
out = sh('free -b')
lines = out.split('\n')
for line in lines:
if line.startswith('Swap'):
_, total, used, free = line.split()
nt = collections.namedtuple('free', 'total used free')
return nt(int(total), int(used), int(free))
raise ValueError(
"can't find 'Swap' in 'free' output:\n%s" % '\n'.join(lines))
def free_physmem():
"""Parse 'free' cmd and return physical memory's total, used
and free values.
"""
# Note: free can have 2 different formats, invalidating 'shared'
# and 'cached' memory which may have different positions so we
# do not return them.
# https://github.com/giampaolo/psutil/issues/538#issuecomment-57059946
out = sh('free -b')
lines = out.split('\n')
for line in lines:
if line.startswith('Mem'):
total, used, free, shared = \
[int(x) for x in line.split()[1:5]]
nt = collections.namedtuple(
'free', 'total used free shared output')
return nt(total, used, free, shared, out)
raise ValueError(
"can't find 'Mem' in 'free' output:\n%s" % '\n'.join(lines))
def vmstat(stat):
out = sh("vmstat -s")
for line in out.split("\n"):
line = line.strip()
if stat in line:
return int(line.split(' ')[0])
raise ValueError("can't find %r in 'vmstat' output" % stat)
def get_free_version_info():
out = sh("free -V").strip()
return tuple(map(int, out.split()[-1].split('.')))
# =====================================================================
# --- system virtual memory
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestSystemVirtualMemory(unittest.TestCase):
def test_total(self):
# free_value = free_physmem().total
# psutil_value = psutil.virtual_memory().total
# self.assertEqual(free_value, psutil_value)
vmstat_value = vmstat('total memory') * 1024
psutil_value = psutil.virtual_memory().total
self.assertAlmostEqual(vmstat_value, psutil_value)
# Older versions of procps used slab memory to calculate used memory.
# This got changed in:
# https://gitlab.com/procps-ng/procps/commit/
# 05d751c4f076a2f0118b914c5e51cfbb4762ad8e
@unittest.skipIf(LINUX and get_free_version_info() < (3, 3, 12),
"old free version")
@retry_before_failing()
def test_used(self):
free = free_physmem()
free_value = free.used
psutil_value = psutil.virtual_memory().used
self.assertAlmostEqual(
free_value, psutil_value, delta=MEMORY_TOLERANCE,
msg='%s %s \n%s' % (free_value, psutil_value, free.output))
@unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@retry_before_failing()
def test_free(self):
# _, _, free_value, _ = free_physmem()
# psutil_value = psutil.virtual_memory().free
# self.assertAlmostEqual(
# free_value, psutil_value, delta=MEMORY_TOLERANCE)
vmstat_value = vmstat('free memory') * 1024
psutil_value = psutil.virtual_memory().free
self.assertAlmostEqual(
vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_buffers(self):
vmstat_value = vmstat('buffer memory') * 1024
psutil_value = psutil.virtual_memory().buffers
self.assertAlmostEqual(
vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
# https://travis-ci.org/giampaolo/psutil/jobs/226719664
@unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@retry_before_failing()
def test_active(self):
vmstat_value = vmstat('active memory') * 1024
psutil_value = psutil.virtual_memory().active
self.assertAlmostEqual(
vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
# https://travis-ci.org/giampaolo/psutil/jobs/227242952
@unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@retry_before_failing()
def test_inactive(self):
vmstat_value = vmstat('inactive memory') * 1024
psutil_value = psutil.virtual_memory().inactive
self.assertAlmostEqual(
vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_shared(self):
free = free_physmem()
free_value = free.shared
if free_value == 0:
raise unittest.SkipTest("free does not support 'shared' column")
psutil_value = psutil.virtual_memory().shared
self.assertAlmostEqual(
free_value, psutil_value, delta=MEMORY_TOLERANCE,
msg='%s %s \n%s' % (free_value, psutil_value, free.output))
@retry_before_failing()
def test_available(self):
# "free" output format has changed at some point:
# https://github.com/giampaolo/psutil/issues/538#issuecomment-147192098
out = sh("free -b")
lines = out.split('\n')
if 'available' not in lines[0]:
raise unittest.SkipTest("free does not support 'available' column")
else:
free_value = int(lines[1].split()[-1])
psutil_value = psutil.virtual_memory().available
self.assertAlmostEqual(
free_value, psutil_value, delta=MEMORY_TOLERANCE,
msg='%s %s \n%s' % (free_value, psutil_value, out))
def test_warnings_on_misses(self):
# Emulate a case where /proc/meminfo provides few info.
# psutil is supposed to set the missing fields to 0 and
# raise a warning.
def open_mock(name, *args, **kwargs):
if name == '/proc/meminfo':
return io.BytesIO(textwrap.dedent("""\
Active(anon): 6145416 kB
Active(file): 2950064 kB
Inactive(anon): 574764 kB
Inactive(file): 1567648 kB
MemAvailable: -1 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
SReclaimable: 346648 kB
""").encode())
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, create=True, side_effect=open_mock) as m:
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ret = psutil.virtual_memory()
assert m.called
self.assertEqual(len(ws), 1)
w = ws[0]
assert w.filename.endswith('psutil/_pslinux.py')
self.assertIn(
"memory stats couldn't be determined", str(w.message))
self.assertIn("cached", str(w.message))
self.assertIn("shared", str(w.message))
self.assertIn("active", str(w.message))
self.assertIn("inactive", str(w.message))
self.assertIn("buffers", str(w.message))
self.assertIn("available", str(w.message))
self.assertEqual(ret.cached, 0)
self.assertEqual(ret.active, 0)
self.assertEqual(ret.inactive, 0)
self.assertEqual(ret.shared, 0)
self.assertEqual(ret.buffers, 0)
self.assertEqual(ret.available, 0)
def test_avail_old_percent(self):
# Make sure that our calculation of avail mem for old kernels
# is off by max 10%.
from psutil._pslinux import calculate_avail_vmem
from psutil._pslinux import open_binary
mems = {}
with open_binary('/proc/meminfo') as f:
for line in f:
fields = line.split()
mems[fields[0]] = int(fields[1]) * 1024
a = calculate_avail_vmem(mems)
if b'MemAvailable:' in mems:
b = mems[b'MemAvailable:']
diff_percent = abs(a - b) / a * 100
self.assertLess(diff_percent, 10)
def test_avail_old_comes_from_kernel(self):
# Make sure "MemAvailable:" coluimn is used instead of relying
# on our internal algorithm to calculate avail mem.
def open_mock(name, *args, **kwargs):
if name == "/proc/meminfo":
return io.BytesIO(textwrap.dedent("""\
Active: 9444728 kB
Active(anon): 6145416 kB
Active(file): 2950064 kB
Buffers: 287952 kB
Cached: 4818144 kB
Inactive(file): 1578132 kB
Inactive(anon): 574764 kB
Inactive(file): 1567648 kB
MemAvailable: 6574984 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
Shmem: 577588 kB
SReclaimable: 346648 kB
""").encode())
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, create=True, side_effect=open_mock) as m:
with warnings.catch_warnings(record=True) as ws:
ret = psutil.virtual_memory()
assert m.called
self.assertEqual(ret.available, 6574984 * 1024)
w = ws[0]
self.assertIn(
"inactive memory stats couldn't be determined", str(w.message))
def test_avail_old_missing_fields(self):
# Remove Active(file), Inactive(file) and SReclaimable
# from /proc/meminfo and make sure the fallback is used
# (free + cached),
def open_mock(name, *args, **kwargs):
if name == "/proc/meminfo":
return io.BytesIO(textwrap.dedent("""\
Active: 9444728 kB
Active(anon): 6145416 kB
Buffers: 287952 kB
Cached: 4818144 kB
Inactive(file): 1578132 kB
Inactive(anon): 574764 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
Shmem: 577588 kB
""").encode())
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, create=True, side_effect=open_mock) as m:
with warnings.catch_warnings(record=True) as ws:
ret = psutil.virtual_memory()
assert m.called
self.assertEqual(ret.available, 2057400 * 1024 + 4818144 * 1024)
w = ws[0]
self.assertIn(
"inactive memory stats couldn't be determined", str(w.message))
def test_avail_old_missing_zoneinfo(self):
# Remove /proc/zoneinfo file. Make sure fallback is used
# (free + cached).
def open_mock(name, *args, **kwargs):
if name == "/proc/meminfo":
return io.BytesIO(textwrap.dedent("""\
Active: 9444728 kB
Active(anon): 6145416 kB
Active(file): 2950064 kB
Buffers: 287952 kB
Cached: 4818144 kB
Inactive(file): 1578132 kB
Inactive(anon): 574764 kB
Inactive(file): 1567648 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
Shmem: 577588 kB
SReclaimable: 346648 kB
""").encode())
elif name == "/proc/zoneinfo":
raise IOError(errno.ENOENT, 'no such file or directory')
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, create=True, side_effect=open_mock) as m:
with warnings.catch_warnings(record=True) as ws:
ret = psutil.virtual_memory()
assert m.called
self.assertEqual(ret.available, 2057400 * 1024 + 4818144 * 1024)
w = ws[0]
self.assertIn(
"inactive memory stats couldn't be determined", str(w.message))
# =====================================================================
# --- system swap memory
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestSystemSwapMemory(unittest.TestCase):
@staticmethod
def meminfo_has_swap_info():
"""Return True if /proc/meminfo provides swap metrics."""
with open("/proc/meminfo") as f:
data = f.read()
return 'SwapTotal:' in data and 'SwapFree:' in data
def test_total(self):
free_value = free_swap().total
psutil_value = psutil.swap_memory().total
return self.assertAlmostEqual(
free_value, psutil_value, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_used(self):
free_value = free_swap().used
psutil_value = psutil.swap_memory().used
return self.assertAlmostEqual(
free_value, psutil_value, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_free(self):
free_value = free_swap().free
psutil_value = psutil.swap_memory().free
return self.assertAlmostEqual(
free_value, psutil_value, delta=MEMORY_TOLERANCE)
def test_missing_sin_sout(self):
with mock.patch('psutil._pslinux.open', create=True) as m:
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ret = psutil.swap_memory()
assert m.called
self.assertEqual(len(ws), 1)
w = ws[0]
assert w.filename.endswith('psutil/_pslinux.py')
self.assertIn(
"'sin' and 'sout' swap memory stats couldn't "
"be determined", str(w.message))
self.assertEqual(ret.sin, 0)
self.assertEqual(ret.sout, 0)
def test_no_vmstat_mocked(self):
# see https://github.com/giampaolo/psutil/issues/722
def open_mock(name, *args, **kwargs):
if name == "/proc/vmstat":
raise IOError(errno.ENOENT, 'no such file or directory')
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, create=True, side_effect=open_mock) as m:
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter("always")
ret = psutil.swap_memory()
assert m.called
self.assertEqual(len(ws), 1)
w = ws[0]
assert w.filename.endswith('psutil/_pslinux.py')
self.assertIn(
"'sin' and 'sout' swap memory stats couldn't "
"be determined and were set to 0",
str(w.message))
self.assertEqual(ret.sin, 0)
self.assertEqual(ret.sout, 0)
def test_meminfo_against_sysinfo(self):
# Make sure the content of /proc/meminfo about swap memory
# matches sysinfo() syscall, see:
# https://github.com/giampaolo/psutil/issues/1015
if not self.meminfo_has_swap_info():
return unittest.skip("/proc/meminfo has no swap metrics")
with mock.patch('psutil._pslinux.cext.linux_sysinfo') as m:
swap = psutil.swap_memory()
assert not m.called
import psutil._psutil_linux as cext
_, _, _, _, total, free, unit_multiplier = cext.linux_sysinfo()
total *= unit_multiplier
free *= unit_multiplier
self.assertEqual(swap.total, total)
self.assertEqual(swap.free, free)
def test_emulate_meminfo_has_no_metrics(self):
# Emulate a case where /proc/meminfo provides no swap metrics
# in which case sysinfo() syscall is supposed to be used
# as a fallback.
def open_mock(name, *args, **kwargs):
if name == "/proc/meminfo":
return io.BytesIO(b"")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, create=True, side_effect=open_mock) as m:
psutil.swap_memory()
assert m.called
# =====================================================================
# --- system CPU
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestSystemCPU(unittest.TestCase):
@unittest.skipIf(TRAVIS, "unknown failure on travis")
def test_cpu_times(self):
fields = psutil.cpu_times()._fields
kernel_ver = re.findall(r'\d+\.\d+\.\d+', os.uname()[2])[0]
kernel_ver_info = tuple(map(int, kernel_ver.split('.')))
if kernel_ver_info >= (2, 6, 11):
self.assertIn('steal', fields)
else:
self.assertNotIn('steal', fields)
if kernel_ver_info >= (2, 6, 24):
self.assertIn('guest', fields)
else:
self.assertNotIn('guest', fields)
if kernel_ver_info >= (3, 2, 0):
self.assertIn('guest_nice', fields)
else:
self.assertNotIn('guest_nice', fields)
@unittest.skipIf(not os.path.exists("/sys/devices/system/cpu/online"),
"/sys/devices/system/cpu/online does not exist")
def test_cpu_count_logical_w_sysdev_cpu_online(self):
with open("/sys/devices/system/cpu/online") as f:
value = f.read().strip()
if "-" in str(value):
value = int(value.split('-')[1]) + 1
self.assertEqual(psutil.cpu_count(), value)
@unittest.skipIf(not os.path.exists("/sys/devices/system/cpu"),
"/sys/devices/system/cpu does not exist")
def test_cpu_count_logical_w_sysdev_cpu_num(self):
ls = os.listdir("/sys/devices/system/cpu")
count = len([x for x in ls if re.search(r"cpu\d+$", x) is not None])
self.assertEqual(psutil.cpu_count(), count)
@unittest.skipIf(not which("nproc"), "nproc utility not available")
def test_cpu_count_logical_w_nproc(self):
num = int(sh("nproc --all"))
self.assertEqual(psutil.cpu_count(logical=True), num)
@unittest.skipIf(not which("lscpu"), "lscpu utility not available")
def test_cpu_count_logical_w_lscpu(self):
out = sh("lscpu -p")
num = len([x for x in out.split('\n') if not x.startswith('#')])
self.assertEqual(psutil.cpu_count(logical=True), num)
def test_cpu_count_logical_mocked(self):
import psutil._pslinux
original = psutil._pslinux.cpu_count_logical()
# Here we want to mock os.sysconf("SC_NPROCESSORS_ONLN") in
# order to cause the parsing of /proc/cpuinfo and /proc/stat.
with mock.patch(
'psutil._pslinux.os.sysconf', side_effect=ValueError) as m:
self.assertEqual(psutil._pslinux.cpu_count_logical(), original)
assert m.called
# Let's have open() return emtpy data and make sure None is
# returned ('cause we mimick os.cpu_count()).
with mock.patch('psutil._pslinux.open', create=True) as m:
self.assertIsNone(psutil._pslinux.cpu_count_logical())
self.assertEqual(m.call_count, 2)
# /proc/stat should be the last one
self.assertEqual(m.call_args[0][0], '/proc/stat')
# Let's push this a bit further and make sure /proc/cpuinfo
# parsing works as expected.
with open('/proc/cpuinfo', 'rb') as f:
cpuinfo_data = f.read()
fake_file = io.BytesIO(cpuinfo_data)
with mock.patch('psutil._pslinux.open',
return_value=fake_file, create=True) as m:
self.assertEqual(psutil._pslinux.cpu_count_logical(), original)
# Finally, let's make /proc/cpuinfo return meaningless data;
# this way we'll fall back on relying on /proc/stat
def open_mock(name, *args, **kwargs):
if name.startswith('/proc/cpuinfo'):
return io.BytesIO(b"")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock, create=True):
self.assertEqual(psutil._pslinux.cpu_count_logical(), original)
def test_cpu_count_physical_mocked(self):
# Have open() return emtpy data and make sure None is returned
# ('cause we want to mimick os.cpu_count())
with mock.patch('psutil._pslinux.open', create=True) as m:
self.assertIsNone(psutil._pslinux.cpu_count_physical())
assert m.called
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
def test_cpu_freq_no_result(self):
with mock.patch("psutil._pslinux.glob.glob", return_value=[]):
self.assertIsNone(psutil.cpu_freq())
@unittest.skipIf(TRAVIS, "fails on Travis")
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
def test_cpu_freq_use_second_file(self):
# https://github.com/giampaolo/psutil/issues/981
def glob_mock(pattern):
if pattern.startswith("/sys/devices/system/cpu/cpufreq/policy"):
flags.append(None)
return []
else:
flags.append(None)
return orig_glob(pattern)
flags = []
orig_glob = glob.glob
with mock.patch("psutil._pslinux.glob.glob", side_effect=glob_mock,
create=True):
assert psutil.cpu_freq()
self.assertEqual(len(flags), 2)
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
def test_cpu_freq_emulate_data(self):
def open_mock(name, *args, **kwargs):
if name.endswith('/scaling_cur_freq'):
return io.BytesIO(b"500000")
elif name.endswith('/scaling_min_freq'):
return io.BytesIO(b"600000")
elif name.endswith('/scaling_max_freq'):
return io.BytesIO(b"700000")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
with mock.patch(
'glob.glob',
return_value=['/sys/devices/system/cpu/cpufreq/policy0']):
freq = psutil.cpu_freq()
self.assertEqual(freq.current, 500.0)
self.assertEqual(freq.min, 600.0)
self.assertEqual(freq.max, 700.0)
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
def test_cpu_freq_emulate_multi_cpu(self):
def open_mock(name, *args, **kwargs):
if name.endswith('/scaling_cur_freq'):
return io.BytesIO(b"100000")
elif name.endswith('/scaling_min_freq'):
return io.BytesIO(b"200000")
elif name.endswith('/scaling_max_freq'):
return io.BytesIO(b"300000")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
policies = ['/sys/devices/system/cpu/cpufreq/policy0',
'/sys/devices/system/cpu/cpufreq/policy1',
'/sys/devices/system/cpu/cpufreq/policy2']
with mock.patch(patch_point, side_effect=open_mock):
with mock.patch('glob.glob', return_value=policies):
freq = psutil.cpu_freq()
self.assertEqual(freq.current, 100.0)
self.assertEqual(freq.min, 200.0)
self.assertEqual(freq.max, 300.0)
@unittest.skipIf(TRAVIS, "fails on Travis")
@unittest.skipIf(not HAS_CPU_FREQ, "not supported")
def test_cpu_freq_no_scaling_cur_freq_file(self):
# See: https://github.com/giampaolo/psutil/issues/1071
def open_mock(name, *args, **kwargs):
if name.endswith('/scaling_cur_freq'):
raise IOError(errno.ENOENT, "")
elif name.endswith('/cpuinfo_cur_freq'):
return io.BytesIO(b"200000")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
policies = ['/sys/devices/system/cpu/cpufreq/policy0',
'/sys/devices/system/cpu/cpufreq/policy1',
'/sys/devices/system/cpu/cpufreq/policy2']
with mock.patch(patch_point, side_effect=open_mock):
with mock.patch('glob.glob', return_value=policies):
freq = psutil.cpu_freq()
self.assertEqual(freq.current, 200)
# Also test that NotImplementedError is raised in case no
# current freq file is present.
def open_mock(name, *args, **kwargs):
if name.endswith('/scaling_cur_freq'):
raise IOError(errno.ENOENT, "")
elif name.endswith('/cpuinfo_cur_freq'):
raise IOError(errno.ENOENT, "")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
with mock.patch('glob.glob', return_value=policies):
self.assertRaises(NotImplementedError, psutil.cpu_freq)
# =====================================================================
# --- system CPU stats
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestSystemCPUStats(unittest.TestCase):
@unittest.skipIf(TRAVIS, "fails on Travis")
def test_ctx_switches(self):
vmstat_value = vmstat("context switches")
psutil_value = psutil.cpu_stats().ctx_switches
self.assertAlmostEqual(vmstat_value, psutil_value, delta=500)
@unittest.skipIf(TRAVIS, "fails on Travis")
def test_interrupts(self):
vmstat_value = vmstat("interrupts")
psutil_value = psutil.cpu_stats().interrupts
self.assertAlmostEqual(vmstat_value, psutil_value, delta=500)
# =====================================================================
# --- system network
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestSystemNetwork(unittest.TestCase):
def test_net_if_addrs_ips(self):
for name, addrs in psutil.net_if_addrs().items():
for addr in addrs:
if addr.family == psutil.AF_LINK:
self.assertEqual(addr.address, get_mac_address(name))
elif addr.family == socket.AF_INET:
self.assertEqual(addr.address, get_ipv4_address(name))
# TODO: test for AF_INET6 family
def test_net_if_stats(self):
for name, stats in psutil.net_if_stats().items():
try:
out = sh("ifconfig %s" % name)
except RuntimeError:
pass
else:
# Not always reliable.
# self.assertEqual(stats.isup, 'RUNNING' in out, msg=out)
self.assertEqual(stats.mtu,
int(re.findall(r'(?i)MTU[: ](\d+)', out)[0]))
@retry_before_failing()
def test_net_io_counters(self):
def ifconfig(nic):
ret = {}
out = sh("ifconfig %s" % name)
ret['packets_recv'] = int(
re.findall(r'RX packets[: ](\d+)', out)[0])
ret['packets_sent'] = int(
re.findall(r'TX packets[: ](\d+)', out)[0])
ret['errin'] = int(re.findall(r'errors[: ](\d+)', out)[0])
ret['errout'] = int(re.findall(r'errors[: ](\d+)', out)[1])
ret['dropin'] = int(re.findall(r'dropped[: ](\d+)', out)[0])
ret['dropout'] = int(re.findall(r'dropped[: ](\d+)', out)[1])
ret['bytes_recv'] = int(
re.findall(r'RX (?:packets \d+ +)?bytes[: ](\d+)', out)[0])
ret['bytes_sent'] = int(
re.findall(r'TX (?:packets \d+ +)?bytes[: ](\d+)', out)[0])
return ret
nio = psutil.net_io_counters(pernic=True, nowrap=False)
for name, stats in nio.items():
try:
ifconfig_ret = ifconfig(name)
except RuntimeError:
continue
self.assertAlmostEqual(
stats.bytes_recv, ifconfig_ret['bytes_recv'], delta=1024 * 5)
self.assertAlmostEqual(
stats.bytes_sent, ifconfig_ret['bytes_sent'], delta=1024 * 5)
self.assertAlmostEqual(
stats.packets_recv, ifconfig_ret['packets_recv'], delta=1024)
self.assertAlmostEqual(
stats.packets_sent, ifconfig_ret['packets_sent'], delta=1024)
self.assertAlmostEqual(
stats.errin, ifconfig_ret['errin'], delta=10)
self.assertAlmostEqual(
stats.errout, ifconfig_ret['errout'], delta=10)
self.assertAlmostEqual(
stats.dropin, ifconfig_ret['dropin'], delta=10)
self.assertAlmostEqual(
stats.dropout, ifconfig_ret['dropout'], delta=10)
@unittest.skipIf(not which('ip'), "'ip' utility not available")
@unittest.skipIf(TRAVIS, "skipped on Travis")
def test_net_if_names(self):
out = sh("ip addr").strip()
nics = [x for x in psutil.net_if_addrs().keys() if ':' not in x]
found = 0
for line in out.split('\n'):
line = line.strip()
if re.search(r"^\d+:", line):
found += 1
name = line.split(':')[1].strip()
self.assertIn(name, nics)
self.assertEqual(len(nics), found, msg="%s\n---\n%s" % (
pprint.pformat(nics), out))
@mock.patch('psutil._pslinux.socket.inet_ntop', side_effect=ValueError)
@mock.patch('psutil._pslinux.supports_ipv6', return_value=False)
def test_net_connections_ipv6_unsupported(self, supports_ipv6, inet_ntop):
# see: https://github.com/giampaolo/psutil/issues/623
try:
s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
self.addCleanup(s.close)
s.bind(("::1", 0))
except socket.error:
pass
psutil.net_connections(kind='inet6')
def test_net_connections_mocked(self):
def open_mock(name, *args, **kwargs):
if name == '/proc/net/unix':
return io.StringIO(textwrap.dedent(u"""\
0: 00000003 000 000 0001 03 462170 @/tmp/dbus-Qw2hMPIU3n
0: 00000003 000 000 0001 03 35010 @/tmp/dbus-tB2X8h69BQ
0: 00000003 000 000 0001 03 34424 @/tmp/dbus-cHy80Y8O
000000000000000000000000000000000000000000000000000000
"""))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
psutil.net_connections(kind='unix')
assert m.called
# =====================================================================
# --- system disk
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestSystemDisks(unittest.TestCase):
@unittest.skipIf(not hasattr(os, 'statvfs'), "os.statvfs() not available")
@skip_on_not_implemented()
def test_disk_partitions_and_usage(self):
# test psutil.disk_usage() and psutil.disk_partitions()
# against "df -a"
def df(path):
out = sh('df -P -B 1 "%s"' % path).strip()
lines = out.split('\n')
lines.pop(0)
line = lines.pop(0)
dev, total, used, free = line.split()[:4]
if dev == 'none':
dev = ''
total, used, free = int(total), int(used), int(free)
return dev, total, used, free
for part in psutil.disk_partitions(all=False):
usage = psutil.disk_usage(part.mountpoint)
dev, total, used, free = df(part.mountpoint)
self.assertEqual(usage.total, total)
# 10 MB tollerance
if abs(usage.free - free) > 10 * 1024 * 1024:
self.fail("psutil=%s, df=%s" % (usage.free, free))
if abs(usage.used - used) > 10 * 1024 * 1024:
self.fail("psutil=%s, df=%s" % (usage.used, used))
def test_disk_partitions_mocked(self):
# Test that ZFS partitions are returned.
with open("/proc/filesystems", "r") as f:
data = f.read()
if 'zfs' in data:
for part in psutil.disk_partitions():
if part.fstype == 'zfs':
break
else:
self.fail("couldn't find any ZFS partition")
else:
# No ZFS partitions on this system. Let's fake one.
fake_file = io.StringIO(u("nodev\tzfs\n"))
with mock.patch('psutil._pslinux.open',
return_value=fake_file, create=True) as m1:
with mock.patch(
'psutil._pslinux.cext.disk_partitions',
return_value=[('/dev/sdb3', '/', 'zfs', 'rw')]) as m2:
ret = psutil.disk_partitions()
assert m1.called
assert m2.called
assert ret
self.assertEqual(ret[0].fstype, 'zfs')
def test_disk_io_counters_kernel_2_4_mocked(self):
# Tests /proc/diskstats parsing format for 2.4 kernels, see:
# https://github.com/giampaolo/psutil/issues/767
def open_mock(name, *args, **kwargs):
if name == '/proc/partitions':
return io.StringIO(textwrap.dedent(u"""\
major minor #blocks name
8 0 488386584 hda
"""))
elif name == '/proc/diskstats':
return io.StringIO(
u(" 3 0 1 hda 2 3 4 5 6 7 8 9 10 11 12"))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
ret = psutil.disk_io_counters(nowrap=False)
assert m.called
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_merged_count, 2)
self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
self.assertEqual(ret.read_time, 4)
self.assertEqual(ret.write_count, 5)
self.assertEqual(ret.write_merged_count, 6)
self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
self.assertEqual(ret.write_time, 8)
self.assertEqual(ret.busy_time, 10)
def test_disk_io_counters_kernel_2_6_full_mocked(self):
# Tests /proc/diskstats parsing format for 2.6 kernels,
# lines reporting all metrics:
# https://github.com/giampaolo/psutil/issues/767
def open_mock(name, *args, **kwargs):
if name == '/proc/partitions':
return io.StringIO(textwrap.dedent(u"""\
major minor #blocks name
8 0 488386584 hda
"""))
elif name == '/proc/diskstats':
return io.StringIO(
u(" 3 0 hda 1 2 3 4 5 6 7 8 9 10 11"))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
ret = psutil.disk_io_counters(nowrap=False)
assert m.called
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_merged_count, 2)
self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
self.assertEqual(ret.read_time, 4)
self.assertEqual(ret.write_count, 5)
self.assertEqual(ret.write_merged_count, 6)
self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
self.assertEqual(ret.write_time, 8)
self.assertEqual(ret.busy_time, 10)
def test_disk_io_counters_kernel_2_6_limited_mocked(self):
# Tests /proc/diskstats parsing format for 2.6 kernels,
# where one line of /proc/partitions return a limited
# amount of metrics when it bumps into a partition
# (instead of a disk). See:
# https://github.com/giampaolo/psutil/issues/767
def open_mock(name, *args, **kwargs):
if name == '/proc/partitions':
return io.StringIO(textwrap.dedent(u"""\
major minor #blocks name
8 0 488386584 hda
"""))
elif name == '/proc/diskstats':
return io.StringIO(
u(" 3 1 hda 1 2 3 4"))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
ret = psutil.disk_io_counters(nowrap=False)
assert m.called
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_bytes, 2 * SECTOR_SIZE)
self.assertEqual(ret.write_count, 3)
self.assertEqual(ret.write_bytes, 4 * SECTOR_SIZE)
self.assertEqual(ret.read_merged_count, 0)
self.assertEqual(ret.read_time, 0)
self.assertEqual(ret.write_merged_count, 0)
self.assertEqual(ret.write_time, 0)
self.assertEqual(ret.busy_time, 0)
# =====================================================================
# --- misc
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestMisc(unittest.TestCase):
def test_boot_time(self):
vmstat_value = vmstat('boot time')
psutil_value = psutil.boot_time()
self.assertEqual(int(vmstat_value), int(psutil_value))
@mock.patch('psutil.traceback.print_exc')
def test_no_procfs_on_import(self, tb):
my_procfs = tempfile.mkdtemp()
with open(os.path.join(my_procfs, 'stat'), 'w') as f:
f.write('cpu 0 0 0 0 0 0 0 0 0 0\n')
f.write('cpu0 0 0 0 0 0 0 0 0 0 0\n')
f.write('cpu1 0 0 0 0 0 0 0 0 0 0\n')
try:
orig_open = open
def open_mock(name, *args, **kwargs):
if name.startswith('/proc'):
raise IOError(errno.ENOENT, 'rejecting access for test')
return orig_open(name, *args, **kwargs)
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
reload_module(psutil)
assert tb.called
self.assertRaises(IOError, psutil.cpu_times)
self.assertRaises(IOError, psutil.cpu_times, percpu=True)
self.assertRaises(IOError, psutil.cpu_percent)
self.assertRaises(IOError, psutil.cpu_percent, percpu=True)
self.assertRaises(IOError, psutil.cpu_times_percent)
self.assertRaises(
IOError, psutil.cpu_times_percent, percpu=True)
psutil.PROCFS_PATH = my_procfs
self.assertEqual(psutil.cpu_percent(), 0)
self.assertEqual(sum(psutil.cpu_times_percent()), 0)
# since we don't know the number of CPUs at import time,
# we awkwardly say there are none until the second call
per_cpu_percent = psutil.cpu_percent(percpu=True)
self.assertEqual(sum(per_cpu_percent), 0)
# ditto awkward length
per_cpu_times_percent = psutil.cpu_times_percent(percpu=True)
self.assertEqual(sum(map(sum, per_cpu_times_percent)), 0)
# much user, very busy
with open(os.path.join(my_procfs, 'stat'), 'w') as f:
f.write('cpu 1 0 0 0 0 0 0 0 0 0\n')
f.write('cpu0 1 0 0 0 0 0 0 0 0 0\n')
f.write('cpu1 1 0 0 0 0 0 0 0 0 0\n')
self.assertNotEqual(psutil.cpu_percent(), 0)
self.assertNotEqual(
sum(psutil.cpu_percent(percpu=True)), 0)
self.assertNotEqual(sum(psutil.cpu_times_percent()), 0)
self.assertNotEqual(
sum(map(sum, psutil.cpu_times_percent(percpu=True))), 0)
finally:
shutil.rmtree(my_procfs)
reload_module(psutil)
self.assertEqual(psutil.PROCFS_PATH, '/proc')
def test_boot_time_mocked(self):
with mock.patch('psutil._pslinux.open', create=True) as m:
self.assertRaises(
RuntimeError,
psutil._pslinux.boot_time)
assert m.called
def test_users_mocked(self):
# Make sure ':0' and ':0.0' (returned by C ext) are converted
# to 'localhost'.
with mock.patch('psutil._pslinux.cext.users',
return_value=[('giampaolo', 'pts/2', ':0',
1436573184.0, True, 2)]) as m:
self.assertEqual(psutil.users()[0].host, 'localhost')
assert m.called
with mock.patch('psutil._pslinux.cext.users',
return_value=[('giampaolo', 'pts/2', ':0.0',
1436573184.0, True, 2)]) as m:
self.assertEqual(psutil.users()[0].host, 'localhost')
assert m.called
# ...otherwise it should be returned as-is
with mock.patch('psutil._pslinux.cext.users',
return_value=[('giampaolo', 'pts/2', 'foo',
1436573184.0, True, 2)]) as m:
self.assertEqual(psutil.users()[0].host, 'foo')
assert m.called
def test_procfs_path(self):
tdir = tempfile.mkdtemp()
try:
psutil.PROCFS_PATH = tdir
self.assertRaises(IOError, psutil.virtual_memory)
self.assertRaises(IOError, psutil.cpu_times)
self.assertRaises(IOError, psutil.cpu_times, percpu=True)
self.assertRaises(IOError, psutil.boot_time)
# self.assertRaises(IOError, psutil.pids)
self.assertRaises(IOError, psutil.net_connections)
self.assertRaises(IOError, psutil.net_io_counters)
self.assertRaises(IOError, psutil.net_if_stats)
self.assertRaises(IOError, psutil.disk_io_counters)
self.assertRaises(IOError, psutil.disk_partitions)
self.assertRaises(psutil.NoSuchProcess, psutil.Process)
finally:
psutil.PROCFS_PATH = "/proc"
os.rmdir(tdir)
def test_sector_size_mock(self):
# Test SECTOR_SIZE fallback in case 'hw_sector_size' file
# does not exist.
def open_mock(name, *args, **kwargs):
if PY3 and isinstance(name, bytes):
name = name.decode()
if "hw_sector_size" in name:
flag.append(None)
raise IOError(errno.ENOENT, '')
else:
return orig_open(name, *args, **kwargs)
flag = []
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
psutil.disk_io_counters()
assert flag
def test_issue_687(self):
# In case of thread ID:
# - pid_exists() is supposed to return False
# - Process(tid) is supposed to work
# - pids() should not return the TID
# See: https://github.com/giampaolo/psutil/issues/687
t = ThreadTask()
t.start()
try:
p = psutil.Process()
tid = p.threads()[1].id
assert not psutil.pid_exists(tid), tid
pt = psutil.Process(tid)
pt.as_dict()
self.assertNotIn(tid, psutil.pids())
finally:
t.stop()
def test_pid_exists_no_proc_status(self):
# Internally pid_exists relies on /proc/{pid}/status.
# Emulate a case where this file is empty in which case
# psutil is supposed to fall back on using pids().
def open_mock(name, *args, **kwargs):
if name == "/proc/%s/status" % os.getpid():
return io.StringIO(u(""))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
assert psutil.pid_exists(os.getpid())
# =====================================================================
# --- sensors
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
@unittest.skipIf(not HAS_BATTERY, "no battery")
class TestSensorsBattery(unittest.TestCase):
@unittest.skipIf(not which("acpi"), "acpi utility not available")
def test_percent(self):
out = sh("acpi -b")
acpi_value = int(out.split(",")[1].strip().replace('%', ''))
psutil_value = psutil.sensors_battery().percent
self.assertAlmostEqual(acpi_value, psutil_value, delta=1)
@unittest.skipIf(not which("acpi"), "acpi utility not available")
def test_power_plugged(self):
out = sh("acpi -b")
if 'unknown' in out.lower():
return unittest.skip("acpi output not reliable")
if 'discharging at zero rate' in out:
plugged = True
else:
plugged = "Charging" in out.split('\n')[0]
self.assertEqual(psutil.sensors_battery().power_plugged, plugged)
def test_emulate_power_plugged(self):
# Pretend the AC power cable is connected.
def open_mock(name, *args, **kwargs):
if name.endswith("AC0/online") or name.endswith("AC/online"):
return io.BytesIO(b"1")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertEqual(psutil.sensors_battery().power_plugged, True)
self.assertEqual(
psutil.sensors_battery().secsleft, psutil.POWER_TIME_UNLIMITED)
assert m.called
def test_emulate_power_plugged_2(self):
# Same as above but pretend /AC0/online does not exist in which
# case code relies on /status file.
def open_mock(name, *args, **kwargs):
if name.endswith("AC0/online") or name.endswith("AC/online"):
raise IOError(errno.ENOENT, "")
elif name.endswith("/status"):
return io.StringIO(u("charging"))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertEqual(psutil.sensors_battery().power_plugged, True)
assert m.called
def test_emulate_power_not_plugged(self):
# Pretend the AC power cable is not connected.
def open_mock(name, *args, **kwargs):
if name.endswith("AC0/online") or name.endswith("AC/online"):
return io.BytesIO(b"0")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertEqual(psutil.sensors_battery().power_plugged, False)
assert m.called
def test_emulate_power_not_plugged_2(self):
# Same as above but pretend /AC0/online does not exist in which
# case code relies on /status file.
def open_mock(name, *args, **kwargs):
if name.endswith("AC0/online") or name.endswith("AC/online"):
raise IOError(errno.ENOENT, "")
elif name.endswith("/status"):
return io.StringIO(u("discharging"))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertEqual(psutil.sensors_battery().power_plugged, False)
assert m.called
def test_emulate_power_undetermined(self):
# Pretend we can't know whether the AC power cable not
# connected (assert fallback to False).
def open_mock(name, *args, **kwargs):
if name.startswith("/sys/class/power_supply/AC0/online") or \
name.startswith("/sys/class/power_supply/AC/online"):
raise IOError(errno.ENOENT, "")
elif name.startswith("/sys/class/power_supply/BAT0/status"):
return io.BytesIO(b"???")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertIsNone(psutil.sensors_battery().power_plugged)
assert m.called
def test_emulate_no_base_files(self):
# Emulate a case where base metrics files are not present,
# in which case we're supposed to get None.
def open_mock(name, *args, **kwargs):
if name.startswith("/sys/class/power_supply/BAT0/energy_now") or \
name.startswith("/sys/class/power_supply/BAT0/charge_now"):
raise IOError(errno.ENOENT, "")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertIsNone(psutil.sensors_battery())
assert m.called
def test_emulate_energy_full_0(self):
# Emulate a case where energy_full files returns 0.
def open_mock(name, *args, **kwargs):
if name.startswith("/sys/class/power_supply/BAT0/energy_full"):
return io.BytesIO(b"0")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertEqual(psutil.sensors_battery().percent, 0)
assert m.called
def test_emulate_energy_full_not_avail(self):
# Emulate a case where energy_full file does not exist.
# Expected fallback on /capacity.
def open_mock(name, *args, **kwargs):
energy_full = "/sys/class/power_supply/BAT0/energy_full"
charge_full = "/sys/class/power_supply/BAT0/charge_full"
if name.startswith(energy_full) or name.startswith(charge_full):
raise IOError(errno.ENOENT, "")
elif name.startswith("/sys/class/power_supply/BAT0/capacity"):
return io.BytesIO(b"88")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertEqual(psutil.sensors_battery().percent, 88)
assert m.called
def test_emulate_no_ac0_online(self):
# Emulate a case where /AC0/online file does not exist.
def path_exists_mock(name):
if name.startswith("/sys/class/power_supply/AC0/online"):
return False
else:
return orig_path_exists(name)
orig_path_exists = os.path.exists
with mock.patch("psutil._pslinux.os.path.exists",
side_effect=path_exists_mock) as m:
psutil.sensors_battery()
assert m.called
def test_emulate_no_power(self):
# Emulate a case where /AC0/online file nor /BAT0/status exist.
def open_mock(name, *args, **kwargs):
if name.startswith("/sys/class/power_supply/AC/online") or \
name.startswith("/sys/class/power_supply/AC0/online") or \
name.startswith("/sys/class/power_supply/BAT0/status"):
raise IOError(errno.ENOENT, "")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
self.assertIsNone(psutil.sensors_battery().power_plugged)
assert m.called
@unittest.skipIf(not LINUX, "LINUX only")
class TestSensorsTemperatures(unittest.TestCase):
@unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
def test_emulate_eio_error(self):
def open_mock(name, *args, **kwargs):
if name.endswith("_input"):
raise OSError(errno.EIO, "")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
with warnings.catch_warnings(record=True) as ws:
self.assertEqual(psutil.sensors_temperatures(), {})
assert m.called
self.assertIn("ignoring", str(ws[0].message))
def test_emulate_data(self):
def open_mock(name, *args, **kwargs):
if name.endswith('/name'):
return io.StringIO(u("name"))
elif name.endswith('/temp1_label'):
return io.StringIO(u("label"))
elif name.endswith('/temp1_input'):
return io.BytesIO(b"30000")
elif name.endswith('/temp1_max'):
return io.BytesIO(b"40000")
elif name.endswith('/temp1_crit'):
return io.BytesIO(b"50000")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
with mock.patch('glob.glob',
return_value=['/sys/class/hwmon/hwmon0/temp1']):
temp = psutil.sensors_temperatures()['name'][0]
self.assertEqual(temp.label, 'label')
self.assertEqual(temp.current, 30.0)
self.assertEqual(temp.high, 40.0)
self.assertEqual(temp.critical, 50.0)
@unittest.skipIf(not LINUX, "LINUX only")
class TestSensorsFans(unittest.TestCase):
def test_emulate_data(self):
def open_mock(name, *args, **kwargs):
if name.endswith('/name'):
return io.StringIO(u("name"))
elif name.endswith('/fan1_label'):
return io.StringIO(u("label"))
elif name.endswith('/fan1_input'):
return io.StringIO(u("2000"))
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
with mock.patch('glob.glob',
return_value=['/sys/class/hwmon/hwmon2/fan1']):
fan = psutil.sensors_fans()['name'][0]
self.assertEqual(fan.label, 'label')
self.assertEqual(fan.current, 2000)
# =====================================================================
# --- test process
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestProcess(unittest.TestCase):
def setUp(self):
safe_rmpath(TESTFN)
tearDown = setUp
def test_memory_full_info(self):
src = textwrap.dedent("""
import time
with open("%s", "w") as f:
time.sleep(10)
""" % TESTFN)
sproc = pyrun(src)
self.addCleanup(reap_children)
call_until(lambda: os.listdir('.'), "'%s' not in ret" % TESTFN)
p = psutil.Process(sproc.pid)
time.sleep(.1)
mem = p.memory_full_info()
maps = p.memory_maps(grouped=False)
self.assertAlmostEqual(
mem.uss, sum([x.private_dirty + x.private_clean for x in maps]),
delta=4096)
self.assertAlmostEqual(
mem.pss, sum([x.pss for x in maps]), delta=4096)
self.assertAlmostEqual(
mem.swap, sum([x.swap for x in maps]), delta=4096)
# On PYPY file descriptors are not closed fast enough.
@unittest.skipIf(PYPY, "unreliable on PYPY")
def test_open_files_mode(self):
def get_test_file():
p = psutil.Process()
giveup_at = time.time() + 2
while True:
for file in p.open_files():
if file.path == os.path.abspath(TESTFN):
return file
elif time.time() > giveup_at:
break
raise RuntimeError("timeout looking for test file")
#
with open(TESTFN, "w"):
self.assertEqual(get_test_file().mode, "w")
with open(TESTFN, "r"):
self.assertEqual(get_test_file().mode, "r")
with open(TESTFN, "a"):
self.assertEqual(get_test_file().mode, "a")
#
with open(TESTFN, "r+"):
self.assertEqual(get_test_file().mode, "r+")
with open(TESTFN, "w+"):
self.assertEqual(get_test_file().mode, "r+")
with open(TESTFN, "a+"):
self.assertEqual(get_test_file().mode, "a+")
# note: "x" bit is not supported
if PY3:
safe_rmpath(TESTFN)
with open(TESTFN, "x"):
self.assertEqual(get_test_file().mode, "w")
safe_rmpath(TESTFN)
with open(TESTFN, "x+"):
self.assertEqual(get_test_file().mode, "r+")
def test_open_files_file_gone(self):
# simulates a file which gets deleted during open_files()
# execution
p = psutil.Process()
files = p.open_files()
with tempfile.NamedTemporaryFile():
# give the kernel some time to see the new file
call_until(p.open_files, "len(ret) != %i" % len(files))
with mock.patch('psutil._pslinux.os.readlink',
side_effect=OSError(errno.ENOENT, "")) as m:
files = p.open_files()
assert not files
assert m.called
# also simulate the case where os.readlink() returns EINVAL
# in which case psutil is supposed to 'continue'
with mock.patch('psutil._pslinux.os.readlink',
side_effect=OSError(errno.EINVAL, "")) as m:
self.assertEqual(p.open_files(), [])
assert m.called
def test_open_files_fd_gone(self):
# Simulate a case where /proc/{pid}/fdinfo/{fd} disappears
# while iterating through fds.
# https://travis-ci.org/giampaolo/psutil/jobs/225694530
p = psutil.Process()
files = p.open_files()
with tempfile.NamedTemporaryFile():
# give the kernel some time to see the new file
call_until(p.open_files, "len(ret) != %i" % len(files))
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point,
side_effect=IOError(errno.ENOENT, "")) as m:
files = p.open_files()
assert not files
assert m.called
# --- mocked tests
def test_terminal_mocked(self):
with mock.patch('psutil._pslinux._psposix.get_terminal_map',
return_value={}) as m:
self.assertIsNone(psutil._pslinux.Process(os.getpid()).terminal())
assert m.called
# TODO: re-enable this test.
# def test_num_ctx_switches_mocked(self):
# with mock.patch('psutil._pslinux.open', create=True) as m:
# self.assertRaises(
# NotImplementedError,
# psutil._pslinux.Process(os.getpid()).num_ctx_switches)
# assert m.called
def test_cmdline_mocked(self):
# see: https://github.com/giampaolo/psutil/issues/639
p = psutil.Process()
fake_file = io.StringIO(u('foo\x00bar\x00'))
with mock.patch('psutil._pslinux.open',
return_value=fake_file, create=True) as m:
self.assertEqual(p.cmdline(), ['foo', 'bar'])
assert m.called
fake_file = io.StringIO(u('foo\x00bar\x00\x00'))
with mock.patch('psutil._pslinux.open',
return_value=fake_file, create=True) as m:
self.assertEqual(p.cmdline(), ['foo', 'bar', ''])
assert m.called
def test_cmdline_spaces_mocked(self):
# see: https://github.com/giampaolo/psutil/issues/1179
p = psutil.Process()
fake_file = io.StringIO(u('foo bar '))
with mock.patch('psutil._pslinux.open',
return_value=fake_file, create=True) as m:
self.assertEqual(p.cmdline(), ['foo', 'bar'])
assert m.called
fake_file = io.StringIO(u('foo bar '))
with mock.patch('psutil._pslinux.open',
return_value=fake_file, create=True) as m:
self.assertEqual(p.cmdline(), ['foo', 'bar', ''])
assert m.called
def test_readlink_path_deleted_mocked(self):
with mock.patch('psutil._pslinux.os.readlink',
return_value='/home/foo (deleted)'):
self.assertEqual(psutil.Process().exe(), "/home/foo")
self.assertEqual(psutil.Process().cwd(), "/home/foo")
def test_threads_mocked(self):
# Test the case where os.listdir() returns a file (thread)
# which no longer exists by the time we open() it (race
# condition). threads() is supposed to ignore that instead
# of raising NSP.
def open_mock(name, *args, **kwargs):
if name.startswith('/proc/%s/task' % os.getpid()):
raise IOError(errno.ENOENT, "")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
ret = psutil.Process().threads()
assert m.called
self.assertEqual(ret, [])
# ...but if it bumps into something != ENOENT we want an
# exception.
def open_mock(name, *args, **kwargs):
if name.startswith('/proc/%s/task' % os.getpid()):
raise IOError(errno.EPERM, "")
else:
return orig_open(name, *args, **kwargs)
with mock.patch(patch_point, side_effect=open_mock):
self.assertRaises(psutil.AccessDenied, psutil.Process().threads)
def test_exe_mocked(self):
with mock.patch('psutil._pslinux.readlink',
side_effect=OSError(errno.ENOENT, "")) as m1:
with mock.patch('psutil.Process.cmdline',
side_effect=psutil.AccessDenied(0, "")) as m2:
# No such file error; might be raised also if /proc/pid/exe
# path actually exists for system processes with low pids
# (about 0-20). In this case psutil is supposed to return
# an empty string.
ret = psutil.Process().exe()
assert m1.called
assert m2.called
self.assertEqual(ret, "")
# ...but if /proc/pid no longer exist we're supposed to treat
# it as an alias for zombie process
with mock.patch('psutil._pslinux.os.path.lexists',
return_value=False):
self.assertRaises(
psutil.ZombieProcess, psutil.Process().exe)
def test_issue_1014(self):
# Emulates a case where smaps file does not exist. In this case
# wrap_exception decorator should not raise NoSuchProcess.
def open_mock(name, *args, **kwargs):
if name.startswith('/proc/%s/smaps' % os.getpid()):
raise IOError(errno.ENOENT, "")
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock) as m:
p = psutil.Process()
with self.assertRaises(IOError) as err:
p.memory_maps()
self.assertEqual(err.exception.errno, errno.ENOENT)
assert m.called
@unittest.skipIf(not HAS_RLIMIT, "not supported")
def test_rlimit_zombie(self):
# Emulate a case where rlimit() raises ENOSYS, which may
# happen in case of zombie process:
# https://travis-ci.org/giampaolo/psutil/jobs/51368273
with mock.patch("psutil._pslinux.cext.linux_prlimit",
side_effect=OSError(errno.ENOSYS, "")) as m:
p = psutil.Process()
p.name()
with self.assertRaises(psutil.ZombieProcess) as exc:
p.rlimit(psutil.RLIMIT_NOFILE)
assert m.called
self.assertEqual(exc.exception.pid, p.pid)
self.assertEqual(exc.exception.name, p.name())
def test_cwd_zombie(self):
with mock.patch("psutil._pslinux.os.readlink",
side_effect=OSError(errno.ENOENT, "")) as m:
p = psutil.Process()
p.name()
with self.assertRaises(psutil.ZombieProcess) as exc:
p.cwd()
assert m.called
self.assertEqual(exc.exception.pid, p.pid)
self.assertEqual(exc.exception.name, p.name())
def test_stat_file_parsing(self):
from psutil._pslinux import CLOCK_TICKS
def open_mock(name, *args, **kwargs):
if name.startswith('/proc/%s/stat' % os.getpid()):
args = [
"0", # pid
"(cat)", # name
"Z", # status
"1", # ppid
"0", # pgrp
"0", # session
"0", # tty
"0", # tpgid
"0", # flags
"0", # minflt
"0", # cminflt
"0", # majflt
"0", # cmajflt
"2", # utime
"3", # stime
"4", # cutime
"5", # cstime
"0", # priority
"0", # nice
"0", # num_threads
"0", # itrealvalue
"6", # starttime
"0", # vsize
"0", # rss
"0", # rsslim
"0", # startcode
"0", # endcode
"0", # startstack
"0", # kstkesp
"0", # kstkeip
"0", # signal
"0", # blocked
"0", # sigignore
"0", # sigcatch
"0", # wchan
"0", # nswap
"0", # cnswap
"0", # exit_signal
"6", # processor
]
return io.BytesIO(" ".join(args).encode())
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
p = psutil.Process()
self.assertEqual(p.name(), 'cat')
self.assertEqual(p.status(), psutil.STATUS_ZOMBIE)
self.assertEqual(p.ppid(), 1)
self.assertEqual(
p.create_time(), 6 / CLOCK_TICKS + psutil.boot_time())
cpu = p.cpu_times()
self.assertEqual(cpu.user, 2 / CLOCK_TICKS)
self.assertEqual(cpu.system, 3 / CLOCK_TICKS)
self.assertEqual(cpu.children_user, 4 / CLOCK_TICKS)
self.assertEqual(cpu.children_system, 5 / CLOCK_TICKS)
self.assertEqual(p.cpu_num(), 6)
def test_status_file_parsing(self):
def open_mock(name, *args, **kwargs):
if name.startswith('/proc/%s/status' % os.getpid()):
return io.BytesIO(textwrap.dedent("""\
Uid:\t1000\t1001\t1002\t1003
Gid:\t1004\t1005\t1006\t1007
Threads:\t66
Cpus_allowed:\tf
Cpus_allowed_list:\t0-7
voluntary_ctxt_switches:\t12
nonvoluntary_ctxt_switches:\t13""").encode())
else:
return orig_open(name, *args, **kwargs)
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
p = psutil.Process()
self.assertEqual(p.num_ctx_switches().voluntary, 12)
self.assertEqual(p.num_ctx_switches().involuntary, 13)
self.assertEqual(p.num_threads(), 66)
uids = p.uids()
self.assertEqual(uids.real, 1000)
self.assertEqual(uids.effective, 1001)
self.assertEqual(uids.saved, 1002)
gids = p.gids()
self.assertEqual(gids.real, 1004)
self.assertEqual(gids.effective, 1005)
self.assertEqual(gids.saved, 1006)
self.assertEqual(p._proc._get_eligible_cpus(), list(range(0, 8)))
@unittest.skipIf(not LINUX, "LINUX only")
class TestProcessAgainstStatus(unittest.TestCase):
"""/proc/pid/stat and /proc/pid/status have many values in common.
Whenever possible, psutil uses /proc/pid/stat (it's faster).
For all those cases we check that the value found in
/proc/pid/stat (by psutil) matches the one found in
/proc/pid/status.
"""
@classmethod
def setUpClass(cls):
cls.proc = psutil.Process()
def read_status_file(self, linestart):
with psutil._psplatform.open_text(
'/proc/%s/status' % self.proc.pid) as f:
for line in f:
line = line.strip()
if line.startswith(linestart):
value = line.partition('\t')[2]
try:
return int(value)
except ValueError:
return value
raise ValueError("can't find %r" % linestart)
def test_name(self):
value = self.read_status_file("Name:")
self.assertEqual(self.proc.name(), value)
def test_status(self):
value = self.read_status_file("State:")
value = value[value.find('(') + 1:value.rfind(')')]
value = value.replace(' ', '-')
self.assertEqual(self.proc.status(), value)
def test_ppid(self):
value = self.read_status_file("PPid:")
self.assertEqual(self.proc.ppid(), value)
def test_num_threads(self):
value = self.read_status_file("Threads:")
self.assertEqual(self.proc.num_threads(), value)
def test_uids(self):
value = self.read_status_file("Uid:")
value = tuple(map(int, value.split()[1:4]))
self.assertEqual(self.proc.uids(), value)
def test_gids(self):
value = self.read_status_file("Gid:")
value = tuple(map(int, value.split()[1:4]))
self.assertEqual(self.proc.gids(), value)
@retry_before_failing()
def test_num_ctx_switches(self):
value = self.read_status_file("voluntary_ctxt_switches:")
self.assertEqual(self.proc.num_ctx_switches().voluntary, value)
value = self.read_status_file("nonvoluntary_ctxt_switches:")
self.assertEqual(self.proc.num_ctx_switches().involuntary, value)
def test_cpu_affinity(self):
value = self.read_status_file("Cpus_allowed_list:")
if '-' in str(value):
min_, max_ = map(int, value.split('-'))
self.assertEqual(
self.proc.cpu_affinity(), list(range(min_, max_ + 1)))
def test_cpu_affinity_eligible_cpus(self):
value = self.read_status_file("Cpus_allowed_list:")
with mock.patch("psutil._pslinux.per_cpu_times") as m:
self.proc._proc._get_eligible_cpus()
if '-' in str(value):
assert not m.called
else:
assert m.called
# =====================================================================
# --- test utils
# =====================================================================
@unittest.skipIf(not LINUX, "LINUX only")
class TestUtils(unittest.TestCase):
def test_open_text(self):
with psutil._psplatform.open_text(__file__) as f:
self.assertEqual(f.mode, 'rt')
def test_open_binary(self):
with psutil._psplatform.open_binary(__file__) as f:
self.assertEqual(f.mode, 'rb')
def test_readlink(self):
with mock.patch("os.readlink", return_value="foo (deleted)") as m:
self.assertEqual(psutil._psplatform.readlink("bar"), "foo")
assert m.called
def test_cat(self):
fname = os.path.abspath(TESTFN)
with open(fname, "wt") as f:
f.write("foo ")
self.assertEqual(psutil._psplatform.cat(TESTFN, binary=False), "foo")
self.assertEqual(psutil._psplatform.cat(TESTFN, binary=True), b"foo")
self.assertEqual(
psutil._psplatform.cat(TESTFN + '??', fallback="bar"), "bar")
if __name__ == '__main__':
run_test_module_by_name(__file__)
PK ! % % test_osx.pynu [
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""OSX specific tests."""
import os
import re
import time
import psutil
from psutil import OSX
from psutil.tests import create_zombie_proc
from psutil.tests import get_test_subprocess
from psutil.tests import HAS_BATTERY
from psutil.tests import MEMORY_TOLERANCE
from psutil.tests import reap_children
from psutil.tests import retry_before_failing
from psutil.tests import run_test_module_by_name
from psutil.tests import sh
from psutil.tests import unittest
PAGESIZE = os.sysconf("SC_PAGE_SIZE") if OSX else None
def sysctl(cmdline):
"""Expects a sysctl command with an argument and parse the result
returning only the value of interest.
"""
out = sh(cmdline)
result = out.split()[1]
try:
return int(result)
except ValueError:
return result
def vm_stat(field):
"""Wrapper around 'vm_stat' cmdline utility."""
out = sh('vm_stat')
for line in out.split('\n'):
if field in line:
break
else:
raise ValueError("line not found")
return int(re.search(r'\d+', line).group(0)) * PAGESIZE
# http://code.activestate.com/recipes/578019/
def human2bytes(s):
SYMBOLS = {
'customary': ('B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'),
}
init = s
num = ""
while s and s[0:1].isdigit() or s[0:1] == '.':
num += s[0]
s = s[1:]
num = float(num)
letter = s.strip()
for name, sset in SYMBOLS.items():
if letter in sset:
break
else:
if letter == 'k':
sset = SYMBOLS['customary']
letter = letter.upper()
else:
raise ValueError("can't interpret %r" % init)
prefix = {sset[0]: 1}
for i, s in enumerate(sset[1:]):
prefix[s] = 1 << (i + 1) * 10
return int(num * prefix[letter])
@unittest.skipIf(not OSX, "OSX only")
class TestProcess(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.pid = get_test_subprocess().pid
@classmethod
def tearDownClass(cls):
reap_children()
def test_process_create_time(self):
output = sh("ps -o lstart -p %s" % self.pid)
start_ps = output.replace('STARTED', '').strip()
hhmmss = start_ps.split(' ')[-2]
year = start_ps.split(' ')[-1]
start_psutil = psutil.Process(self.pid).create_time()
self.assertEqual(
hhmmss,
time.strftime("%H:%M:%S", time.localtime(start_psutil)))
self.assertEqual(
year,
time.strftime("%Y", time.localtime(start_psutil)))
@unittest.skipIf(not OSX, "OSX only")
class TestZombieProcessAPIs(unittest.TestCase):
@classmethod
def setUpClass(cls):
zpid = create_zombie_proc()
cls.p = psutil.Process(zpid)
@classmethod
def tearDownClass(cls):
reap_children(recursive=True)
def test_pidtask_info(self):
self.assertEqual(self.p.status(), psutil.STATUS_ZOMBIE)
self.p.ppid()
self.p.uids()
self.p.gids()
self.p.terminal()
self.p.create_time()
def test_exe(self):
self.assertRaises(psutil.ZombieProcess, self.p.exe)
def test_cmdline(self):
self.assertRaises(psutil.ZombieProcess, self.p.cmdline)
def test_environ(self):
self.assertRaises(psutil.ZombieProcess, self.p.environ)
def test_cwd(self):
self.assertRaises(psutil.ZombieProcess, self.p.cwd)
def test_memory_full_info(self):
self.assertRaises(psutil.ZombieProcess, self.p.memory_full_info)
def test_cpu_times(self):
self.assertRaises(psutil.ZombieProcess, self.p.cpu_times)
def test_num_ctx_switches(self):
self.assertRaises(psutil.ZombieProcess, self.p.num_ctx_switches)
def test_num_threads(self):
self.assertRaises(psutil.ZombieProcess, self.p.num_threads)
def test_open_files(self):
self.assertRaises(psutil.ZombieProcess, self.p.open_files)
def test_connections(self):
self.assertRaises(psutil.ZombieProcess, self.p.connections)
def test_num_fds(self):
self.assertRaises(psutil.ZombieProcess, self.p.num_fds)
def test_threads(self):
self.assertRaises((psutil.ZombieProcess, psutil.AccessDenied),
self.p.threads)
def test_memory_maps(self):
self.assertRaises(psutil.ZombieProcess, self.p.memory_maps)
@unittest.skipIf(not OSX, "OSX only")
class TestSystemAPIs(unittest.TestCase):
# --- disk
def test_disks(self):
# test psutil.disk_usage() and psutil.disk_partitions()
# against "df -a"
def df(path):
out = sh('df -k "%s"' % path).strip()
lines = out.split('\n')
lines.pop(0)
line = lines.pop(0)
dev, total, used, free = line.split()[:4]
if dev == 'none':
dev = ''
total = int(total) * 1024
used = int(used) * 1024
free = int(free) * 1024
return dev, total, used, free
for part in psutil.disk_partitions(all=False):
usage = psutil.disk_usage(part.mountpoint)
dev, total, used, free = df(part.mountpoint)
self.assertEqual(part.device, dev)
self.assertEqual(usage.total, total)
# 10 MB tollerance
if abs(usage.free - free) > 10 * 1024 * 1024:
self.fail("psutil=%s, df=%s" % usage.free, free)
if abs(usage.used - used) > 10 * 1024 * 1024:
self.fail("psutil=%s, df=%s" % usage.used, used)
# --- cpu
def test_cpu_count_logical(self):
num = sysctl("sysctl hw.logicalcpu")
self.assertEqual(num, psutil.cpu_count(logical=True))
def test_cpu_count_physical(self):
num = sysctl("sysctl hw.physicalcpu")
self.assertEqual(num, psutil.cpu_count(logical=False))
def test_cpu_freq(self):
freq = psutil.cpu_freq()
self.assertEqual(
freq.current * 1000 * 1000, sysctl("sysctl hw.cpufrequency"))
self.assertEqual(
freq.min * 1000 * 1000, sysctl("sysctl hw.cpufrequency_min"))
self.assertEqual(
freq.max * 1000 * 1000, sysctl("sysctl hw.cpufrequency_max"))
# --- virtual mem
def test_vmem_total(self):
sysctl_hwphymem = sysctl('sysctl hw.memsize')
self.assertEqual(sysctl_hwphymem, psutil.virtual_memory().total)
@retry_before_failing()
def test_vmem_free(self):
vmstat_val = vm_stat("free")
psutil_val = psutil.virtual_memory().free
self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_vmem_available(self):
vmstat_val = vm_stat("inactive") + vm_stat("free")
psutil_val = psutil.virtual_memory().available
self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_vmem_active(self):
vmstat_val = vm_stat("active")
psutil_val = psutil.virtual_memory().active
self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_vmem_inactive(self):
vmstat_val = vm_stat("inactive")
psutil_val = psutil.virtual_memory().inactive
self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
@retry_before_failing()
def test_vmem_wired(self):
vmstat_val = vm_stat("wired")
psutil_val = psutil.virtual_memory().wired
self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
# --- swap mem
@retry_before_failing()
def test_swapmem_sin(self):
vmstat_val = vm_stat("Pageins")
psutil_val = psutil.swap_memory().sin
self.assertEqual(psutil_val, vmstat_val)
@retry_before_failing()
def test_swapmem_sout(self):
vmstat_val = vm_stat("Pageout")
psutil_val = psutil.swap_memory().sout
self.assertEqual(psutil_val, vmstat_val)
# Not very reliable.
# def test_swapmem_total(self):
# out = sh('sysctl vm.swapusage')
# out = out.replace('vm.swapusage: ', '')
# total, used, free = re.findall('\d+.\d+\w', out)
# psutil_smem = psutil.swap_memory()
# self.assertEqual(psutil_smem.total, human2bytes(total))
# self.assertEqual(psutil_smem.used, human2bytes(used))
# self.assertEqual(psutil_smem.free, human2bytes(free))
# --- network
def test_net_if_stats(self):
for name, stats in psutil.net_if_stats().items():
try:
out = sh("ifconfig %s" % name)
except RuntimeError:
pass
else:
self.assertEqual(stats.isup, 'RUNNING' in out, msg=out)
self.assertEqual(stats.mtu,
int(re.findall(r'mtu (\d+)', out)[0]))
# --- sensors_battery
@unittest.skipIf(not HAS_BATTERY, "no battery")
def test_sensors_battery(self):
out = sh("pmset -g batt")
percent = re.search("(\d+)%", out).group(1)
drawing_from = re.search("Now drawing from '([^']+)'", out).group(1)
power_plugged = drawing_from == "AC Power"
psutil_result = psutil.sensors_battery()
self.assertEqual(psutil_result.power_plugged, power_plugged)
self.assertEqual(psutil_result.percent, int(percent))
if __name__ == '__main__':
run_test_module_by_name(__file__)
PK !
test_sunos.pynu [
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Sun OS specific tests."""
import os
import psutil
from psutil import SUNOS
from psutil.tests import run_test_module_by_name
from psutil.tests import sh
from psutil.tests import unittest
@unittest.skipIf(not SUNOS, "SUNOS only")
class SunOSSpecificTestCase(unittest.TestCase):
def test_swap_memory(self):
out = sh('env PATH=/usr/sbin:/sbin:%s swap -l' % os.environ['PATH'])
lines = out.strip().split('\n')[1:]
if not lines:
raise ValueError('no swap device(s) configured')
total = free = 0
for line in lines:
line = line.split()
t, f = line[-2:]
total += int(int(t) * 512)
free += int(int(f) * 512)
used = total - free
psutil_swap = psutil.swap_memory()
self.assertEqual(psutil_swap.total, total)
self.assertEqual(psutil_swap.used, used)
self.assertEqual(psutil_swap.free, free)
def test_cpu_count(self):
out = sh("/usr/sbin/psrinfo")
self.assertEqual(psutil.cpu_count(), len(out.split('\n')))
if __name__ == '__main__':
run_test_module_by_name(__file__)
PK ! nrX rX / __pycache__/test_contracts.cpython-36.opt-1.pycnu [ 3
JZ2^ @ s d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
ddl m Z ddl m Z ddl m
Z
ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
l mZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# dd lm$Z$ dd lm%Z% dd lm&Z& dd lm'Z' ddl Z G d d! d!e$j(Z)G d"d# d#e$j(Z*G d$d% d%e$j(Z+G d&d' d'e$j(Z,e-d(kre e. dS ))zContracts tests. These tests mainly check API sanity in terms of
returned types and APIs availability.
Some of these are duplicates of tests test_system.py and test_process.py
N)closing)AIX)BSD)FREEBSD)LINUX)NETBSD)OPENBSD)OSX)POSIX)SUNOS)WINDOWS)callable)long)bind_unix_socket)check_connection_ntuple)get_kernel_version)HAS_CONNECTIONS_UNIX)
HAS_RLIMIT)HAS_SENSORS_FANS)HAS_SENSORS_TEMPERATURES)
is_namedtuple)run_test_module_by_name) safe_rmpath)skip_on_access_denied)TESTFN)unittest)unix_socket_path)VALID_PROC_STATUSES)warnc @ s e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.S )/TestAvailabilityzQMake sure code reflects what doc promises in terms of APIs
availability.
c C s$ t p
tp
t}| jttjd| d S )N cpu_affinity)r r r assertEqualhasattrpsutilProcess)selfhasit r' &/usr/lib64/python3.6/test_contracts.pytest_cpu_affinity< s z"TestAvailability.test_cpu_affinityc C s( | j ttdt | j ttdt d S )NZwin_service_iterZwin_service_get)r! r" r# r )r% r' r' r( test_win_service@ s z!TestAvailability.test_win_servicec C s | j ttdtptpt d S )NZ PROCFS_PATH)r! r" r# r r r )r% r' r' r( test_PROCFS_PATHD s z!TestAvailability.test_PROCFS_PATHc C sj | j }|ttdt |ttdt |ttdt |ttdt |ttdt |ttdt d S )NZABOVE_NORMAL_PRIORITY_CLASSZBELOW_NORMAL_PRIORITY_CLASSZHIGH_PRIORITY_CLASSZIDLE_PRIORITY_CLASSZNORMAL_PRIORITY_CLASSZREALTIME_PRIORITY_CLASS)r! r" r# r )r% aer' r' r( test_win_priorityH s z"TestAvailability.test_win_priorityc C sJ | j }|ttdt |ttdt |ttdt |ttdt d S )NZIOPRIO_CLASS_NONEZIOPRIO_CLASS_RTZIOPRIO_CLASS_BEZIOPRIO_CLASS_IDLE)r! r" r# r )r% r, r' r' r( test_linux_ioprioQ s
z"TestAvailability.test_linux_ioprioc C sH | j }tot dk}|ttjd| |ttd| |ttd| |ttd| |ttd| |ttd | |ttd
| |ttd | |ttd | |ttd
| |ttd| |ttd| |ttd| tot dk}|ttd| |ttd| |ttd| |ttd| |ttd| d S )N $ rlimitZ
RLIM_INFINITYZ RLIMIT_ASZ RLIMIT_COREZ
RLIMIT_CPUZ RLIMIT_DATAZ RLIMIT_FSIZEZ RLIMIT_LOCKSZRLIMIT_MEMLOCK
RLIMIT_NOFILEZ RLIMIT_NPROCZ
RLIMIT_RSSZ RLIMIT_STACK r ZRLIMIT_MSGQUEUEZ RLIMIT_NICEZ
RLIMIT_RTPRIOZ
RLIMIT_RTTIMEZRLIMIT_SIGPENDING)r/ r0 r1 )r4 r )r! r r r" r# r$ )r% r, r& r' r' r( test_linux_rlimitX s* z"TestAvailability.test_linux_rlimitc C s: t otjjdptjjd}| jttd|p2tp2t d S )Nz /sys/devices/system/cpu/cpufreqz$/sys/devices/system/cpu/cpu0/cpufreqZcpu_freq) r ospathexistsr! r" r# r r )r% linuxr' r' r(
test_cpu_freqp s z TestAvailability.test_cpu_freqc C s | j ttdt d S )Nsensors_temperatures)r! r" r# r )r% r' r' r( test_sensors_temperaturesv s z*TestAvailability.test_sensors_temperaturesc C s | j ttdt d S )N sensors_fans)r! r" r# r )r% r' r' r( test_sensors_fansy s z"TestAvailability.test_sensors_fansc C s" | j ttdtptptpt d S )NZsensors_battery)r! r" r# r r r r )r% r' r' r( test_battery| s z TestAvailability.test_batteryc C s | j ttjdtptpt d S )Nenviron)r! r" r# r$ r r r )r% r' r' r( test_proc_environ s z"TestAvailability.test_proc_environc C s | j ttjdt d S )Nuids)r! r" r# r$ r
)r% r' r' r( test_proc_uids s z TestAvailability.test_proc_uidsc C s | j ttjdt d S )NrB )r! r" r# r$ r
)r% r' r' r( test_proc_gids s z TestAvailability.test_proc_gidsc C s | j ttjdt d S )Nterminal)r! r" r# r$ r
)r% r' r' r( test_proc_terminal s z#TestAvailability.test_proc_terminalc C s | j ttjdtpt d S )Nionice)r! r" r# r$ r r )r% r' r' r( test_proc_ionice s z!TestAvailability.test_proc_ionicec C s | j ttjdt d S )Nr2 )r! r" r# r$ r )r% r' r' r( test_proc_rlimit s z!TestAvailability.test_proc_rlimitc C s( t tjd}| j|tstr dnd d S )N io_countersFT)r" r# r$ r! r r )r% r& r' r' r( test_proc_io_counters s z&TestAvailability.test_proc_io_countersc C s | j ttjdt d S )Nnum_fds)r! r" r# r$ r
)r% r' r' r( test_proc_num_fds s z"TestAvailability.test_proc_num_fdsc C s | j ttjdt d S )N num_handles)r! r" r# r$ r )r% r' r' r( test_proc_num_handles s z&TestAvailability.test_proc_num_handlesc C s | j ttjdtptpt d S )Nr )r! r" r# r$ r r r )r% r' r' r( test_proc_cpu_affinity s z'TestAvailability.test_proc_cpu_affinityc C s | j ttjdtptpt d S )Ncpu_num)r! r" r# r$ r r r )r% r' r' r( test_proc_cpu_num s z"TestAvailability.test_proc_cpu_numc C s, t tjd}| j|ts ts tr"dnd d S )N memory_mapsFT)r" r# r$ r! r r r )r% r& r' r' r( test_proc_memory_maps s z&TestAvailability.test_proc_memory_mapsN)__name__
__module__ __qualname____doc__r) r* r+ r- r. r5 r: r< r> r? rA rC rD rF rH rI rK rM rO rP rR rT r' r' r' r( r 7 s. r c @ s e Zd Zdd ZdS )TestDeprecationsc C sd t jdd}tj j W d Q R X |d }| j|j t | jdt |j
| jdt |j
d S )NT)recordr z memory_info_ex() is deprecatedzuse memory_info() instead) warningscatch_warningsr# r$ memory_info_exassertIsInstancecategory
FutureWarningassertInstrmessage)r% Zwswr' r' r( test_memory_info_ex s z$TestDeprecations.test_memory_info_exN)rU rV rW re r' r' r' r( rY s rY c @ s e Zd ZdZedd Zdd Zdd Zdd Zd
d Z e
j e d e
j e
d
eeddd Zdd Zdd Zdd Ze
j e ddd Ze
j e ddd Zd d Zd S )
TestSystemzCheck the return types of system related APIs.
Mainly we want to test we never return unicode on Python 2, see:
https://github.com/giampaolo/psutil/issues/1039
c C s t j | _d S )N)r# r$ proc)clsr' r' r(
setUpClass s zTestSystem.setUpClassc C s t t d S )N)r r )r% r' r' r( tearDown s zTestSystem.tearDownc C s2 t j }x$|D ] }| j|t | j|d qW d S )Nr )r# cpu_timesr^ floatassertGreaterEqual)r% retnr' r' r( test_cpu_times s
zTestSystem.test_cpu_timesc C s& x t jddD ]}| j|t qW d S )NT)Zperdisk)r# Zdisk_io_countersr^ rb )r% kr' r' r( test_io_counters s zTestSystem.test_io_countersc C sN xHt j D ]<}| j|jt | j|jt | j|jt | j|jt q
W d S )N)r# Zdisk_partitionsr^ Zdevicerb Z
mountpointZfstypeZopts)r% Zdiskr' r' r( test_disk_partitions s
z TestSystem.test_disk_partitionsz
POSIX onlyzcan't list UNIX sockets)Zonly_ifc C sV t F}tt|. tjdd}x|D ]}| j|jt q(W W d Q R X W d Q R X d S )NZunix)Zkind)r r r r# Znet_connectionsr^ Zladdrrb )r% nameZconsconnr' r' r( test_net_connections s
z TestSystem.test_net_connectionsc C sr xlt j j D ]\\}}| j|t xF|D ]>}| j|jt | j|jttd f | j|jttd f q(W qW d S )N) r# Z net_if_addrsitemsr^ rb ZaddressZnetmasktypeZ broadcast)r% ifnameZaddrsaddrr' r' r( test_net_if_addrs s
z TestSystem.test_net_if_addrsc C s* x$t j j D ]\}}| j|t qW d S )N)r# Z net_if_statsrw r^ rb )r% ry _r' r' r( test_net_if_stats s z TestSystem.test_net_if_statsc C s. x(t jddj D ]\}}| j|t qW d S )NT)Zpernic)r# Znet_io_countersrw r^ rb )r% ry r| r' r' r( test_net_io_counters s z TestSystem.test_net_io_countersz
not supportedc C sF x@t j j D ]0\}}| j|t x|D ]}| j|jt q(W qW d S )N)r# r= rw r^ rb label)r% rt unitsunitr' r' r( r> s
z TestSystem.test_sensors_fansc C sF x@t j j D ]0\}}| j|t x|D ]}| j|jt q(W qW d S )N)r# r; rw r^ rb r )r% rt r r r' r' r( r< s
z$TestSystem.test_sensors_temperaturesc C sf x`t j D ]T}| j|jt | j|jttd f | j|jttd f | j|jt td f q
W d S )N)
r# usersr^ rt rb rE rx hostpidint)r% userr' r' r(
test_users s
zTestSystem.test_usersN)rU rV rW rX classmethodri rj rp rr rs r ZskipIfr
r r r rv r{ r} r~ r r> r r< r r' r' r' r( rf s rf c @ s( e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.d/ Zd0d1 Zd2d3 Z d4d5 Z d6d7 Z d8d9 Z d:d; Z dd? Z"d@dA Z#dBdC Z$dDdE Z%dFdG Z&dHS )ITestFetchAllProcessesz~Test which iterates over all running processes and performs
some sanity checks against Process API's returned values.
c C sd t r`dd l}dd l}|j }|j }tdd |D | _tdd |D | _tdd |D | _d S )Nr c S s g | ]
}|j qS r' )Zpw_uid).0xr' r' r(
( s z/TestFetchAllProcesses.setUp..c S s g | ]
}|j qS r' )Zpw_name)r r r' r' r( r ) s c S s g | ]
}|j qS r' )Zgr_gid)r r r' r' r( r * s ) r
pwdgrpZgetpwallZgetgrallsetall_uids
all_usernamesall_gids)r% r r r groupsr' r' r( setUp" s zTestFetchAllProcesses.setUpc C s d}t dddddddd d
d d g }tr6t r6|jd
g }x2ttjD ]$}|jdrVqF||kr`qF|j| qFW t }g }x tj
D ]}|j x|D ]}|}ydf } i }
t ||d } | d k rt
| r|d
krtjf} n|dkrddi}
| | |
}n| }|d7 }W n2 tk
r> d| jjd | } t| Y q tjtjfk
r }
z0| j|
j|j |
jr| j|
j|j W Y d d }
~
X q tk
r> }
zddd d }|d||f 7 }||kr|dt| 7 }|d7 }|dd 7 }|d tj 7 }dj d d |j D }|d7 }|j| P W Y d d }
~
X qX |dd g d d i fkrVt | |}||| qW W d Q R X qW |r| j d j | d S )!Nr Z send_signalZsuspendZresumeZ terminatekillwaitZas_dictparentZchildrenr] oneshotr2 r| rS ZgroupedF z&%r was skipped because not implementedz.test_
=F zFAIL: test_%s (proc=%sz , ret=%s)z)
-z
%sc s s | ]}d| V qdS ) Nz r' )r ir' r' r( c s z7TestFetchAllProcesses.test_fetch_all..g ) r r r adddirr# r$
startswithappendobjectZ process_iterr getattrr
r3 NotImplementedError __class__rU r Z
NoSuchProcessZ AccessDeniedr! r rt Exceptionrepr traceback
format_excjoin
splitlinesZfail)r% Z valid_procsZexcluded_namesZattrsrt defaultZfailuresprn argskwargsattrmsgerrsmethr' r' r( test_fetch_all, st
z$TestFetchAllProcesses.test_fetch_allc C s* | j |t x|D ]}| j |t qW d S )N)r^ listrb )r% rn rg partr' r' r( cmdlinet s
z TestFetchAllProcesses.cmdlinec C sN | j |ttd f |s&| j|d n$trJtjj|rJttdrJttdrJd S )Nr accessX_OK) r^ rb rx r! r
r6 r7 isfiler" )r% rn rg r' r' r( exey s zTestFetchAllProcesses.exec C s | j |t | j|d d S )Nr )r^ r rm )r% rn rg r' r' r( r s zTestFetchAllProcesses.pidc C s | j |ttf | j|d d S )Nr )r^ r r rm )r% rn rg r' r' r( ppid s zTestFetchAllProcesses.ppidc C s | j |t tsd S )N)r^ rb r )r% rn rg r' r' r( rt s zTestFetchAllProcesses.namec C s^ | j |t y| j|d W n* tk
rF tr@|j tjkr@n Y nX tj dtj
| d S )Nr z%Y %m %d %H:%M:%S) r^ rl rm AssertionErrorr statusr# Z
STATUS_ZOMBIEtimeZstrftimeZ localtime)r% rn rg r' r' r( create_time s z!TestFetchAllProcesses.create_timec C s8 x2|D ]*}| j |t | j|d | j|| j qW d S )Nr )r^ r rm ra r )r% rn rg Zuidr' r' r( rB s
zTestFetchAllProcesses.uidsc C sD x>|D ]6}| j |t t rt r| j|d | j|| j qW d S )Nr )r^ r r r rm ra r )r% rn rg gidr' r' r( gids s
zTestFetchAllProcesses.gidsc C s" | j |t tr | j|| j d S )N)r^ rb r
ra r )r% rn rg r' r' r( username s z TestFetchAllProcesses.usernamec C s( | j |t | j|d | j|t d S )N?)r^ rb ZassertNotEqualra r )r% rn rg r' r' r( r s z TestFetchAllProcesses.statusc C s6 x0|D ](}| j |ttf |dkr| j|d qW d S )Nr r )r^ r r rm )r% rn rg fieldr' r' r( rJ s
z!TestFetchAllProcesses.io_countersc C s\ t r x|D ]}| j|t q
W tr@| j|jd | j|jd n| j|d | j|d d S )Nr r r/ )r r r/ )r
r^ r r rm Zioclassvaluera )r% rn rg r r' r' r( rG s
z TestFetchAllProcesses.ionicec C s | j |t | j|d d S )Nr )r^ r rm )r% rn rg r' r' r( num_threads s z!TestFetchAllProcesses.num_threadsc C sf | j |t xT|D ]L}| j|jd | j|jd | j|jd x |D ]}| j |ttf qFW qW d S )Nr )r^ r rm idZ user_timeZ system_timer rl )r% rn rg tr r' r' r( threads s
z TestFetchAllProcesses.threadsc C s* x$|D ] }| j |t | j|d qW d S )Nr )r^ rl rm )r% rn rg ro r' r' r( rk s
z TestFetchAllProcesses.cpu_timesc C s | j |t d S )N)r^ rl )r% rn rg r' r' r( cpu_percent s z!TestFetchAllProcesses.cpu_percentc C s\ | j |t tr |dkr d S | j|d tj dkr@| j|d | j|tt tj d S )Nr r r )
r^ r r rm r# cpu_countr! ra r range)r% rn rg r' r' r( rQ s z TestFetchAllProcesses.cpu_numc C s x(|D ] }| j |ttf | j|d qW trtt rt|jdkrtxx|jD ](}|dkrFt||}| j |j||d qFW nDt
r| j|j |j | j|j
|j | j|j|j | j|j|j d S )Nr vms)r )r^ r r rm r
r r _fieldsr
assertGreaterr Z peak_wsetZwsetZpeak_paged_poolZ
paged_poolZpeak_nonpaged_poolZ
nonpaged_poolZ
peak_pagefileZpagefile)r% rn rg r rt r' r' r( memory_info s
z!TestFetchAllProcesses.memory_infoc C sv t j j}xR|jD ]H}t||}| j|ttf | j|d||fd | j |||||fd qW t
rr| j|j |j d S )Nr )r )
r# Zvirtual_memorytotalr r r^ r r rm ZassertLessEqualr ZpssZuss)r% rn rg r rt r r' r' r( memory_full_info s
z&TestFetchAllProcesses.memory_full_infoc C s | j |t x|D ]}| j |jt | j |jt trF| j|jd qtr| j |j t | j |j
t | j |j t | j |j d | j
|j
d | j|j d qtr|j rqqW d S )
Nr r rrd ar+a+r )r rd r r r )r^ r fdr r7 rb r r! r Zpositionmodeflagsrm ra r r )r% rn rg fr' r' r(
open_files s
z TestFetchAllProcesses.open_filesc C s | j |t | j|d d S )Nr )r^ r rm )r% rn rg r' r' r( rL ( s z TestFetchAllProcesses.num_fdsc C s2 | j t|tt| x|D ] }t| q W d S )N)r! lenr r )r% rn rg ru r' r' r( connections, s
z!TestFetchAllProcesses.connectionsc C sh |rd| j |t ytj|}W nD tk
rb } z(trD|jtjj krDn|jtj
krR W Y d d }~X nX d S )N) r^ rb r6 statOSErrorr errnor# Z _psplatformZACCESS_DENIED_SETENOENT)r% rn rg str r' r' r( cwd1 s
zTestFetchAllProcesses.cwdc C s | j |t d S )N)r^ rl )r% rn rg r' r' r( memory_percentA s z$TestFetchAllProcesses.memory_percentc C s | j |t d S )N)r^ bool)r% rn rg r' r' r(
is_runningE s z TestFetchAllProcesses.is_runningc C sB | j |t ttj }x$|D ] }| j |t | j|| q W d S )N)r^ r r r# r r ra )r% rn rg Zcpusro r' r' r( r H s
z"TestFetchAllProcesses.cpu_affinityc C s | j |ttd f |d k r d S )N)r^ rb rx )r% rn rg r' r' r( rE P s z TestFetchAllProcesses.terminalc C s x|D ]}| j |jt | j |jt | j |jt xR|jD ]H}t||}|dkr^|jdsq<|dkrhq<| j |tt f | j
|d q.)r^ r r
r r# ra )r% rn rg Z
prioritiesr' r' r( nicem s
zTestFetchAllProcesses.nicec C s. x(|D ] }| j |ttf | j|d qW d S )Nr )r^ r r rm )r% rn rg r r' r' r( num_ctx_switchesv s
z&TestFetchAllProcesses.num_ctx_switchesc C s@ | j |t | jt|d | j|d d | j|d d d S )Nr/ r r r r )r^ tupler! r rm )r% rn rg r' r' r( r2 | s z TestFetchAllProcesses.rlimitc C s> | j |t x,|j D ] \}}| j |t | j |t qW d S )N)r^ dictrw rb )r% rn rg rq vr' r' r( r@ s z TestFetchAllProcesses.environN)'rU rV rW rX r r r r r r rt r rB r r r rJ rG r r rk r rQ r r r rL r r r r r rE rS rN r r r2 r@ r' r' r' r( r sH
H
r __main__)/rX r r6 r r r r[
contextlibr r# r r r r r r r r
r r Zpsutil._compatr
r Z psutil.testsr r r r r r r r r r r r r r r r ZTestCaser rY rf r rU __file__r' r' r' r( sX x^ n
PK ! D D # __pycache__/test_bsd.cpython-36.pycnu [ 3
JZcE @ s d Z ddlZddlZddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddl
m Z ddl
m Z dd l
m
Z
dd
l
mZ dd l
mZ dd l
mZ dd
l
mZ ddl
mZ ddl
mZ erejdZej dkredZqdZndZdd Zdd Zeje dG dd dejZ eje dG dd dejZ eje d G d d d ejZ eje d G d d! d!ejZ e d"kree! dS )#z$Tests specific to all BSD platforms. N)BSD)FREEBSD)NETBSD)OPENBSD)get_test_subprocess) HAS_BATTERY)MEMORY_TOLERANCE)
reap_children)retry_before_failing)run_test_module_by_name)sh)unittest)which SC_PAGE_SIZEmuseFc C sh t d| }tr(||jdd d }n ts0trF||jdd d }yt|S tk
rb |S X dS )zmExpects a sysctl command with an argument and parse the result
returning only the value of interest.
zsysctl z: N= )r r findr r int
ValueError)cmdlineresult r /usr/lib64/python3.6/test_bsd.pysysctl+ s r c C s@ t d}x&|jdD ]}|j| rP qW tdt|j d S )z+Thin wrapper around 'muse' cmdline utility.r
zline not foundr )r split
startswithr r )Zfieldoutliner r r r : s
zBSD onlyc @ s e Zd ZdZedd Zedd Zeje ddd Z
d d
Z eje d d d
d Z
eje d d dd Zdd ZdS )BSDSpecificTestCasez)Generic tests common to all BSD variants.c C s t j| _d S )N)r pid)clsr r r
setUpClassN s z BSDSpecificTestCase.setUpClassc C s
t d S )N)r )r# r r r
tearDownClassR s z!BSDSpecificTestCase.tearDownClassz -o lstart doesn't work on NETBSDc C sP t d| j }|jddj }tj| jj }tjdtj |}| j
|| d S )Nzps -o lstart -p %sZSTARTED z%a %b %e %H:%M:%S %Y) r r" replacestrippsutilProcessZ create_timetimeZstrftimeZ localtime assertEqual)selfoutputZstart_psZ start_psutilr r r test_process_create_timeV s z,BSDSpecificTestCase.test_process_create_timec C s dd }xt jddD ]}t j|j}||j\}}}}| j|j| | j|j| t|j| d krz| j d|j|f t|j
| d kr| j d|j
|f qW d S ) Nc S s t d| j }|jd}|jd |jd}|j d d \}}}}|dkrRd}t|d }t|d }t|d }||||fS )Nz
df -k "%s"r r Znoner& i )r r( r popr )pathr linesr devtotalusedfreer r r dfb s
z*BSDSpecificTestCase.test_disks..dfF)all
i zpsutil=%s, df=%si ( i i ( i ) r) Zdisk_partitionsZ
disk_usageZ
mountpointr, Zdevicer5 absr7 Zfailr6 )r- r8 partZusager4 r5 r6 r7 r r r
test_disks_ s
z BSDSpecificTestCase.test_disksr zsysctl cmd not availablec C s t d}| jtjdd| d S )Nzhw.ncpuT)Zlogical)r r, r) cpu_count)r- systr r r test_cpu_count_logicalz s z*BSDSpecificTestCase.test_cpu_count_logicalc C s t d}| j|tj j d S )Nz
hw.physmem)r r, r) virtual_memoryr5 )r- numr r r test_virtual_memory_total s z-BSDSpecificTestCase.test_virtual_memory_totalc C s xzt j j D ]j\}}ytd| }W n tk
r: Y qX | j|jd|k|d d|kr| j|jtt j
d|d qW d S )Nz ifconfig %sZRUNNING)msgmtuz mtu (\d+)r ) r) Z net_if_statsitemsr RuntimeErrorr, ZisuprE r refindall)r- nameZstatsr r r r test_net_if_stats s z%BSDSpecificTestCase.test_net_if_statsN)__name__
__module__ __qualname____doc__ classmethodr$ r% r
skipIfr r/ r= r r@ rC rK r r r r r! J s r! z FREEBSD onlyc @ s e Zd Zedd Zedd Ze dd Zdd Zd d
Z d d Z
e d
d Z e dd Z e dd Z
e dd Ze dd Ze dd Ze dd Ze dd Zeje d d d Zeje d e d d! Zeje d e d"d# Zeje d e d$d% Zeje d e d&d' Zeje d e d(d) Zeje d e d*d+ Z d,d- Z d.d/ Z d0d1 Z d2d3 Z d4d5 Z!eje" d6d7d8 Z#eje" d6d9d: Z$eje"d;dS )?FreeBSDSpecificTestCasec C s t j| _d S )N)r r" )r# r r r r$ s z"FreeBSDSpecificTestCase.setUpClassc C s
t d S )N)r )r# r r r r% s z%FreeBSDSpecificTestCase.tearDownClassc C s t d| j }tj| jjdd}|jddd }x||r|j }|j }|d d \}}}} }
|j } | jd||f | j | jt |
| j
| j j ds6| j|d | j q6W d S )
Nzprocstat -v %sF)Zgroupedr r z%s-%s[r: )
r r" r) r* Z memory_mapsr r1 r, Zaddrr Zrssr2 r ) r- r mapsr3 r fields_startstopZpermsresmapr r r test_proc_memory_maps s z-FreeBSDSpecificTestCase.test_proc_memory_mapsc C s< t d| j }| jtj| jj |jdd j d d S )Nzprocstat -b %sr r )r r" r, r) r* Zexer )r- r r r r
test_proc_exe s z%FreeBSDSpecificTestCase.test_proc_exec C sL t d| j }| jdjtj| jj dj|jdd j dd d S )Nzprocstat -c %s r r r )r r" r, joinr) r* r r )r- r r r r test_proc_cmdline s z)FreeBSDSpecificTestCase.test_proc_cmdlinec C s t d| j }|jdd j dd \}}}}}}tj| j}|j } |j }
| j| jt | | j| j
t | | j| j t | | j|
jt | | j|
j
t | | j|
j t | d S )Nzprocstat -s %sr r r ) r r" r r) r* uidsgidsr, realr Z effectiveZsaved) r- r ZeuidZruidZsuidZegidZrgidZsgidprc rd r r r test_proc_uids_gids s & z+FreeBSDSpecificTestCase.test_proc_uids_gidsc C s g }t d| j }tj| j}x|jdD ]}|j j }d|krtt|j d }|j j }| j
|| |j d q*d|kr*t|j d }|j j }| j
|| |j d q*W t
|dkrtdd S )
Nzprocstat -r %sr z voluntary contextr z involuntary contextr z)couldn't find lines match in procstat outr] r] )r r" r) r* r lowerr( r Znum_ctx_switchesZ voluntaryr, appendZ involuntarylenrG )r- testedr rf r pstat_value psutil_valuer r r test_proc_ctx_switches s"
z.FreeBSDSpecificTestCase.test_proc_ctx_switchesc C s g }t d| j }tj| j}x|jdD ]}|j j }d|krtd|j d
jdd }|j j }| j
|| |j d q*d|kr*td|j d jdd
}|j j }| j
|| |j d q*W t
|dkrtd d S )Nzprocstat -r %sr z user timez0.r .z system timer z)couldn't find lines match in procstat outr] r] r] r] )r r" r) r* r rh r( floatZ cpu_timesuserr, ri systemrj rG )r- rk r rf r rl rm r r r test_proc_cpu_times s"
z+FreeBSDSpecificTestCase.test_proc_cpu_timesc C s& t dt }| jtj j|td d S )Nzvm.stats.vm.v_active_count)delta)r PAGESIZEassertAlmostEqualr) rA activer )r- r? r r r test_vmem_active s z(FreeBSDSpecificTestCase.test_vmem_activec C s& t dt }| jtj j|td d S )Nz vm.stats.vm.v_inactive_count)rt )r ru rv r) rA inactiver )r- r? r r r test_vmem_inactive s z*FreeBSDSpecificTestCase.test_vmem_inactivec C s& t dt }| jtj j|td d S )Nzvm.stats.vm.v_wire_count)rt )r ru rv r) rA wiredr )r- r? r r r test_vmem_wired s z'FreeBSDSpecificTestCase.test_vmem_wiredc C s& t dt }| jtj j|td d S )Nzvm.stats.vm.v_cache_count)rt )r ru rv r) rA cachedr )r- r? r r r test_vmem_cached s z(FreeBSDSpecificTestCase.test_vmem_cachedc C s& t dt }| jtj j|td d S )Nzvm.stats.vm.v_free_count)rt )r ru rv r) rA r7 r )r- r? r r r test_vmem_free s z&FreeBSDSpecificTestCase.test_vmem_freec C s" t d}| jtj j|td d S )Nz vfs.bufspace)rt )r rv r) rA buffersr )r- r? r r r test_vmem_buffers s z)FreeBSDSpecificTestCase.test_vmem_bufferszmuse not installedc C s t d}| jtj j| d S )NZTotal)r r, r) rA r5 )r- rB r r r test_muse_vmem_total s z,FreeBSDSpecificTestCase.test_muse_vmem_totalc C s" t d}| jtj j|td d S )NZActive)rt )r rv r) rA rw r )r- rB r r r test_muse_vmem_active s z-FreeBSDSpecificTestCase.test_muse_vmem_activec C s" t d}| jtj j|td d S )NZInactive)rt )r rv r) rA ry r )r- rB r r r test_muse_vmem_inactive# s z/FreeBSDSpecificTestCase.test_muse_vmem_inactivec C s" t d}| jtj j|td d S )NZWired)rt )r rv r) rA r{ r )r- rB r r r test_muse_vmem_wired* s z,FreeBSDSpecificTestCase.test_muse_vmem_wiredc C s" t d}| jtj j|td d S )NZCache)rt )r rv r) rA r} r )r- rB r r r test_muse_vmem_cached1 s z-FreeBSDSpecificTestCase.test_muse_vmem_cachedc C s" t d}| jtj j|td d S )NZFree)rt )r rv r) rA r7 r )r- rB r r r test_muse_vmem_free8 s z+FreeBSDSpecificTestCase.test_muse_vmem_freec C s" t d}| jtj j|td d S )NZBuffer)rt )r rv r) rA r r )r- rB r r r test_muse_vmem_buffers? s z.FreeBSDSpecificTestCase.test_muse_vmem_buffersc C s | j tj jtddd d S )Nzvm.stats.sys.v_swtchi )rt )rv r) cpu_stats ctx_switchesr )r- r r r test_cpu_stats_ctx_switchesF s z3FreeBSDSpecificTestCase.test_cpu_stats_ctx_switchesc C s | j tj jtddd d S )Nzvm.stats.sys.v_intri )rt )rv r) r
interruptsr )r- r r r test_cpu_stats_interruptsJ s z1FreeBSDSpecificTestCase.test_cpu_stats_interruptsc C s | j tj jtddd d S )Nzvm.stats.sys.v_softi )rt )rv r) r Zsoft_interruptsr )r- r r r test_cpu_stats_soft_interruptsN s z6FreeBSDSpecificTestCase.test_cpu_stats_soft_interruptsc C s | j tj jtddd d S )Nzvm.stats.sys.v_syscalli )rt )rv r) r Zsyscallsr )r- r r r test_cpu_stats_syscallsR s z/FreeBSDSpecificTestCase.test_cpu_stats_syscallsc C sL t d}||jdd d }|d |jd }t|}| j|tj d S )Nzsysctl kern.boottimez sec = ,)r r r r, r) boot_time)r- sZbtimer r r test_boot_time\ s
z&FreeBSDSpecificTestCase.test_boot_timez
no batteryc C s dd }t d}tdd |jdD }tj }t|d jdd }|d
}| j|j| |d krt| j|j tj
n| j||j | d S ) Nc S s( t | d\}}t |d\}}d||f S )N< z%d:%02d)divmod)Zsecsmr hr r r
secs2hoursg s z@FreeBSDSpecificTestCase.test_sensors_battery..secs2hoursz
acpiconf -i 0c S s( g | ] }|j d d |j d d fqS ) r r r] )r ).0xr r r
m s z@FreeBSDSpecificTestCase.test_sensors_battery..r zRemaining capacity:%r& zRemaining time:unknown) r dictr r) sensors_batteryr r' r, percentsecsleftZPOWER_TIME_UNLIMITED)r- r r rV Zmetricsr Zremaining_timer r r test_sensors_batterye s z,FreeBSDSpecificTestCase.test_sensors_batteryc C sl | j tj jtd | j tj jtddk tj j}|dk rT| j tdd n| j |tdd d S )Nzhw.acpi.battery.lifezhw.acpi.acliner r zhw.acpi.battery.timer r] )r, r) r r r Z
power_pluggedr )r- r r r r #test_sensors_battery_against_sysctlx s
z;FreeBSDSpecificTestCase.test_sensors_battery_against_sysctlz has batteryc C s@ | j t td td td W d Q R X | jtj d S )Nzhw.acpi.battery.lifezhw.acpi.battery.timezhw.acpi.acline)Z assertRaisesrG r Z assertIsNoner) r )r- r r r test_sensors_battery_no_battery s
z7FreeBSDSpecificTestCase.test_sensors_battery_no_batteryN)&rL rM rN rP r$ r% r
r\ r^ ra rg rn rs rx rz r| r~ r r r
rQ MUSE_AVAILABLEr r r r r r r r r r r r r r r r r r r r rR sF
rR z OPENBSD onlyc @ s e Zd Zdd ZdS )OpenBSDSpecificTestCasec C s6 t d}tjj|d}tjjtj }| j|| d S )Nz
kern.boottimez%a %b %d %H:%M:%S %Y)r datetimeZstrptimeZ
fromtimestampr) r r, )r- r Zsys_btZ psutil_btr r r r s z&OpenBSDSpecificTestCase.test_boot_timeN)rL rM rN r r r r r r s r z NETBSD onlyc @ s` e Zd Zedd Zdd Zdd Zdd Zd d
Zd d Z d
d Z
dd Z dd Z dd Z
dS )NetBSDSpecificTestCasec C sR t dd2}x*|D ]"}|j| rt|j d d S qW W d Q R X td| d S )Nz
/proc/meminforbr i z
can't find %s)openr r r r )Zlook_forfr r r r
parse_meminfo s
"z$NetBSDSpecificTestCase.parse_meminfoc C s | j tj j| jd d S )Nz MemTotal:)r, r) rA r5 r )r- r r r test_vmem_total s z&NetBSDSpecificTestCase.test_vmem_totalc C s | j tj j| jdtd d S )NzMemFree:)rt )rv r) rA r7 r r )r- r r r r s z%NetBSDSpecificTestCase.test_vmem_freec C s | j tj j| jdtd d S )NzBuffers:)rt )rv r) rA r r r )r- r r r r s z(NetBSDSpecificTestCase.test_vmem_buffersc C s | j tj j| jdtd d S )Nz
MemShared:)rt )rv r) rA Zsharedr r )r- r r r test_vmem_shared s z'NetBSDSpecificTestCase.test_vmem_sharedc C s | j tj j| jdtd d S )Nz
SwapTotal:)rt )rv r) swap_memoryr5 r r )r- r r r test_swapmem_total s z)NetBSDSpecificTestCase.test_swapmem_totalc C s | j tj j| jdtd d S )Nz SwapFree:)rt )rv r) r r7 r r )r- r r r test_swapmem_free s z(NetBSDSpecificTestCase.test_swapmem_freec C s" t j }| j|j|j|j d S )N)r) r r, r6 r5 r7 )r- Zsmemr r r test_swapmem_used s z(NetBSDSpecificTestCase.test_swapmem_usedc C sb t dd8}x0|D ] }|jdrt|j d }P qW tdW d Q R X | jtj j|dd d S )Nz
/proc/statr s intrr zcouldn't find linei )rt ) r r r r r rv r) r r )r- r r r r r r r s
z0NetBSDSpecificTestCase.test_cpu_stats_interruptsc C sb t dd8}x0|D ] }|jdrt|j d }P qW tdW d Q R X | jtj j|dd d S )Nz
/proc/statr s ctxtr zcouldn't find linei )rt ) r r r r r rv r) r r )r- r r r r r r r s
z2NetBSDSpecificTestCase.test_cpu_stats_ctx_switchesN)rL rM rN staticmethodr r r r r r r r r r r r r r r s r __main__)"rO r osrH r+ r) r r r r Z psutil.testsr r r r r
r r r
r sysconfru getuidr r r rQ ZTestCaser! rR r r rL __file__r r r r sL
K
B
PK ! Za a , __pycache__/test_system.cpython-36.opt-1.pycnu [ 3
JZ/ @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl m
Z
ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
lmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddlm%Z% ddlm&Z& ddlm'Z' dd lm(Z( dd lm)Z) dd lm*Z* dd lm+Z+ dd lm,Z, dd!lm-Z- G d"d# d#e-j.Z/e0d$kre(e1 dS )%zTests for system APIS. N)AIX)BSD)FREEBSD)LINUX)NETBSD)OPENBSD)OSX)POSIX)SUNOS)WINDOWS)long)APPVEYOR)ASCII_FS)check_net_address)DEVNULL)enum)get_test_subprocess) HAS_BATTERY) HAS_CPU_FREQ)HAS_SENSORS_BATTERY)HAS_SENSORS_FANS)HAS_SENSORS_TEMPERATURES)mock)
reap_children)retry_before_failing)run_test_module_by_name) safe_rmpath)TESTFN)TESTFN_UNICODE)TRAVIS)unittestc @ sB e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
e j e
ddd Zdd Zdd Zdd Zdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Z d/d0 Z d1d2 Z d3d4 Z d5d6 Z d7d8 Z!d9d: Z"d;d< Z#d=d> Z$d?d@ Z%dAdB Z&dCdD Z'dEdF Z(dGdH Z)e j e*dIdJdK Z+e j e,o\e-j.j/dL dMe j e0ote1j2 dNkdOdPdQ Z3dRdS Z4e j e0pe*oe1j5 dTdUdV Z6dWdX Z7e j e8 dYdZd[ Z9d\d] Z:e j e; d^d_d` Z d^e j e? dcddde Z@e j eA d^dfdg ZBdNS )hTestSystemAPIsz Tests for system-related APIs.c C s t t d S )N)r r )self r# #/usr/lib64/python3.6/test_system.pysetUp> s zTestSystemAPIs.setUpc C s
t d S )N)r )r" r# r# r$ tearDownA s zTestSystemAPIs.tearDownc C s | j tj dd tj D t }| j |jdd tj D tj|j}|j |j | j
|jdd tj D t j dtj
tj d | jttj g W d Q R X t j dtjtj d* | jtj ttj W d Q R X W d Q R X d S )Nc S s g | ]
}|j qS r# )pid).0xr# r# r$
E s z4TestSystemAPIs.test_process_iter..c S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* G s c S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* K s zpsutil.Process) side_effect)assertInosgetpidpsutil process_iterr r' Processkillwait assertNotInr patchZ
NoSuchProcess assertEquallist AccessDenied assertRaises)r" sprocpr# r# r$ test_process_iterD s z TestSystemAPIs.test_process_iterc C s" x.t jdgdD ] }| jt|jj dg qW | jt tt jdgd W d Q R X tj dt j
dddB}x:t jddgdD ]&}| j |jd | j |jd d qW W d Q R X tj dt j
dddL}t
}x>t jddg|d D ](}| j|jd | | j |jd d qW W d Q R X d S )
Nr' )attrsZfooz$psutil._psplatform.Process.cpu_timesr )r+ cpu_times)r= Zad_value)r/ r0 r6 r7 infokeysr9
ValueErrorr r5 r8 assertIsNoneassertGreaterEqualobjectassertIs)r" r; mflagr# r# r$ test_prcess_iter_w_paramsU s$
z(TestSystemAPIs.test_prcess_iter_w_paramsc s fdd}g t }t }t }dd |||fD }jttj|dd jttj|dd tj }tj|d|d \}}jtj | d
j|g jt |d j g x |D ]} j
t | d qW t d
fdd}
|j
|
||\}}j|jdd |D tr4j|j jtj nj|j jd j |jg x |D ]} j
t | d q\W t d
fdd}
|j
|j
|
||\}}jt t|j|j|jg x |D ]} jt | d qW d S )Nc s j | j d S )N)appendr' )r; )pidsr# r$ callbackj s z0TestSystemAPIs.test_wait_procs..callbackc S s g | ]}t j|jqS r# )r/ r1 r' )r( r) r# r# r$ r* q s z2TestSystemAPIs.test_wait_procs.. )timeout)rL g{Gz?)rN rL g ?
returncode c s< t j| d|d\}} jt|d jt|d ||fS )Ng Q?)rN rL rM )r/
wait_procsr6 len)procsrL gonealive)r" r# r$ test~ s
z,TestSystemAPIs.test_wait_procs..testc S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* s c s< t j| d|d\}} jt|d jt|d ||fS )Ng Q?)rN rL rO r )r/ rS r6 rT )rU rL rV rW )r" r# r$ rX s
)r r9 rB r/ rS TypeErrortime
assertLessr6 rT assertFalsehasattrr terminater, r' r poprP signalSIGTERMset
assertTrue) r" rL sproc1sproc2sproc3rU trV rW r; rX r# )rK r" r$ test_wait_procsi sB
z TestSystemAPIs.test_wait_procsc C sN t }t }t }dd |||fD }x|D ] }|j q,W tj|\}}d S )Nc S s g | ]}t j|jqS r# )r/ r1 r' )r( r) r# r# r$ r* s z=TestSystemAPIs.test_wait_procs_no_timeout..)r r_ r/ rS )r" re rf rg rU r; rV rW r# r# r$ test_wait_procs_no_timeout s
z)TestSystemAPIs.test_wait_procs_no_timeoutc C s4 t j }| j|t | j|d | j|tj d S )Nr )r/ Z boot_timeassertIsInstancefloat
assertGreaterr\ r[ )r" Zbtr# r# r$ test_boot_time s z TestSystemAPIs.test_boot_timez
POSIX onlyc C s" dd l }| jtjd|j d S )Nr SC_PAGE_SIZE)resourcer6 r- sysconfZ getpagesize)r" rp r# r# r$
test_PAGESIZE s z TestSystemAPIs.test_PAGESIZEc C s t j }xt|jD ]j}t||}|dkr6| j|ttf |dkr|dksX| jd||f ||jkr| jd||j||f qW d S )Npercenttotalr z %r < 0 (%s)z %r > total (total=%s, %s=%s)) r/ Zvirtual_memory_fieldsgetattrrk intr failrt )r" memnamevaluer# r# r$ test_virtual_memory s
z"TestSystemAPIs.test_virtual_memoryc C s& t j }| j|jd |jdkr"n d S ) Nrt usedfreers sinsoutr )rt r} r~ rs r r )r/ Z swap_memoryr6 ru rt )r" ry r# r# r$ test_swap_memory s
z TestSystemAPIs.test_swap_memoryc C st t }| jtj|j tj|j}|j |j | jtj|j | jtjd | j tjddtj
k d S )NrM r rY ) r rd r/
pid_existsr' r1 r2 r3 r] r6 rK )r" r: r; r# r# r$ test_pid_exists s z TestSystemAPIs.test_pid_existsc C s t tj }xF|D ]>}yW q tk
rP tjd |tj krL| j| Y qX qW tt|d t|d }x |D ]}| j tj
||d qvW d S )Ng?i ip )msg) r r/ rK AssertionErrorr[ sleeprx rangemaxr] r )r" rK r' r# r# r$ test_pid_exists_2 s
z TestSystemAPIs.test_pid_exists_2c C sJ dd t j D }t j }| j|j |j | jt|tt| d S )Nc S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* s z,TestSystemAPIs.test_pids..)r/ r0 rK r6 sortrT rc )r" ZplistZpidlistr# r# r$ test_pids s zTestSystemAPIs.test_pidsc C s& t j}tt _z tj W d |t _X d S )N)sysstdoutr r/ rX )r" r r# r# r$ test_test s
zTestSystemAPIs.test_testc
C s t j }| j|tt jdd | j|d tjjdrft d}|j
}W d Q R X d|krft j dt jdd}| j|d | j|| d S ) NT)percpurM z
/proc/cpuinfoz physical idz#cpuinfo doesn't include physical idF)logical)
r/ cpu_countr6 rT r? rD r- pathexistsopenreadr ZSkipTest)r" r fdZ cpuinfo_dataZphysicalr# r# r$ test_cpu_count s
z TestSystemAPIs.test_cpu_countc C sf x`d D ]X}t jd|d}| jtj W d Q R X t jd|d}| jtjdd W d Q R X qW d S )
NrM r z$psutil._psplatform.cpu_count_logical) return_valuez%psutil._psplatform.cpu_count_physicalF)r rY )rY r N)r r5 rC r/ r )r" valrG r# r# r$ test_cpu_count_none s
z"TestSystemAPIs.test_cpu_count_nonec C s^ d}t j }t| x,|D ]$}| j|t | j|d ||7 }qW | j|t| t| d S )Nr g )r/ r? sumrk rl rD r6 str)r" rt timescp_timer# r# r$ test_cpu_times s
z TestSystemAPIs.test_cpu_timesc C sD t tj }tjd t tj }|| }|dks@| jd| d S )Ng?g?z
difference %s)r r/ r? r[ r rx )r" t1t2
differencer# r# r$ test_cpu_times_time_increases: s
z,TestSystemAPIs.test_cpu_times_time_increasesc C s xft jddD ]V}d}t| x,|D ]$}| j|t | j|d ||7 }q$W | j|t| t| qW | jtt jddd tt jdd d S )NT)r r g F) r/ r? r rk rl rD r6 r rT )r" r rt r r# r# r$ test_per_cpu_timesC s
z!TestSystemAPIs.test_per_cpu_timesc C s t jdd}tj d }xtj |krP qW t jdd}x.rM )delta)r/ r? _maker ru assertAlmostEqualrv )r" baseZper_cpuZ
summed_valuesZfieldr# r# r$ test_cpu_times_comparisont s z(TestSystemAPIs.test_cpu_times_comparisonc C s y<| j |t | j|d | j|d | j|dtj W n@ tk
r| } z$td|tj |tj |f W Y d d }~X nX d S )Ng g Y@z
%s
last=%s
new=%sg )
rk rl rD Z assertIsNotassertLessEqualr/ r r pprintZpformat)r" rs Zlast_retZnew_reterrr# r# r$ _test_cpu_percent~ s z TestSystemAPIs._test_cpu_percentc
C sb t jdd}x.tdD ]"}t jd d}| j||| |}qW | jt t jdd W d Q R X d S )NgMbP?)intervald rM rY )r/ cpu_percentr r r9 rB )r" lastr) newr# r# r$ test_cpu_percent s z TestSystemAPIs.test_cpu_percentc C s t jddd}| jt|t j x>tdD ]2}t jd dd}x|D ]}| j||| qDW |}q,W | jt t jddd W d Q R X d S )NgMbP?T)r r r rM rY ) r/ r r6 rT r r r r9 rB )r" r r) r rs r# r# r$ test_per_cpu_percent s
z#TestSystemAPIs.test_per_cpu_percentc C s` t jdd}xNtdD ]B}t jd d}x|D ]}| j||| q,W | jt||| |}qW d S )NgMbP?)r r )r/ cpu_times_percentr r r )r" r r) r rs r# r# r$ test_cpu_times_percent s
z%TestSystemAPIs.test_cpu_times_percentc C s t jddd}| jt|t j x^tdD ]R}t jd dd}x:|D ]2}x|D ]}| j||| qNW | jt||| qDW |}q,W d S )NgMbP?T)r r r )r/ r r6 rT r r r r )r" r r) r cpurs r# r# r$ test_per_cpu_times_percent s
z)TestSystemAPIs.test_per_cpu_times_percentc
C sr t jdd dd t jddD }tjd|d8 x0t jddD ] }x|D ]}| j|d d qJW q@W W d Q R X d S )NT)r c S s* g | ]"}|j d d tt|jD qS )c S s g | ]}d qS )r r# )r( r) r# r# r$ r* s zQTestSystemAPIs.test_per_cpu_times_percent_negative...)r r rT ru )r( r) r# r# r$ r* s zFTestSystemAPIs.test_per_cpu_times_percent_negative..zpsutil.cpu_times)r )r/ r r? r r5 r )r" Z
zero_timesr rs r# r# r$ #test_per_cpu_times_percent_negative s
z2TestSystemAPIs.test_per_cpu_times_percent_negativec
C s t jtj }| j|jd ttdrptjtj }d }| j|j|j | j |j
|j
|d | j |j |j |d t j
}| jt}t j| W d Q R X | j|jjtj d S ) Nrt r} r~ rs
disk_usage i )r )rt r} r~ rs i i P )r/ r r- getcwdr6 ru r^ shutilrt r r~ r} tempfileZmktempr9 OSErrorZ exceptionerrnoENOENT)r" ZusageZ shutil_usageZ toleranceZfnameexcr# r# r$ test_disk_usage s
z TestSystemAPIs.test_disk_usagec C s( t r$| jt tjt W d Q R X d S )N)r r9 UnicodeEncodeErrorr/ r r )r" r# r# r$ test_disk_usage_unicode s z&TestSystemAPIs.test_disk_usage_unicodec C s t jd d S )N .)r/ r )r" r# r# r$ test_disk_usage_bytes s z$TestSystemAPIs.test_disk_usage_bytesc C s t jdd}| j||d xj|D ]b}| j|jt | j|jt | j|jt | j|jt t rld|jkrlq t
srn|j t st r q q W t jdd}| j||d xt jddD ]}t s(yt
j|j W nP tk
r } z2t rtr|jtjkrw|jtjtjfkr W Y d d }~X nX t s(t r(n | j|jt | j|jt qW dd }|t}dd t jddD }| j|| t j| d S )
NF)all)r ZcdromTc S s2 t jj| } x t jj| s(t jj| } qW | j S )N)r- r abspathismountdirnamelower)r r# r# r$ find_mount_point s z=TestSystemAPIs.test_disk_partitions..find_mount_pointc S s g | ]}|j j qS r# )
mountpointr )r( r) r# r# r$ r* s z7TestSystemAPIs.test_disk_partitions..)r/ Zdisk_partitionsrd rk Zdevicer r ZfstypeZoptsr r r
r r- statr r r ZEIOZEPERMZEACCES__file__r, r )r" lsZdiskr r ZmountZmountsr# r# r$ test_disk_partitions sH
z#TestSystemAPIs.test_disk_partitionsc sl fdd}t jdd}|| t jdd} j|g x.|D ]&} j| j|t ||| q>W d S )Nc s j | d | j j | d | j j | d | j j | d | j j | d | j j | d | j j | d | j j | d | j d S ) Nr rM rR rO r ) r6 Z
bytes_sentZ
bytes_recvZ packets_sentZ packets_recvZerrinZerroutZdropinZdropout)nt)r" r# r$ check_ntuple s z9TestSystemAPIs.test_net_io_counters..check_ntupleF)pernicT)r/ net_io_countersassertNotEqualrd rk r )r" r retkeyr# )r" r$ test_net_io_counters s
z#TestSystemAPIs.test_net_io_countersc C sD t jdi d,}| jtjdd | jtjddi W d Q R X d S )Nz"psutil._psplatform.net_io_counters)r F)r T)r r5 rC r/ r r6 )r" rG r# r# r$ test_net_io_counters_no_nics8 s
z+TestSystemAPIs.test_net_io_counters_no_nicsc
C sh t j }t j }ttjtjt jg}x|j D ]\}}| j |t
| j t t|t | x|D ]}| j |j
t | j |jt
| j |jt
td f | j |jt
td f | j|j
| tjdkr| j |j
tj || jr|j
tjkr*tj|j
}tj| |j|jdf W d Q R X nj|j
tjkrtj |jdtjtj dtj d }|\} }
} } }
tj| |
| }tj| |j|
W d Q R X xB|j|j|j|j fD ]*}|d k r|j
tjkrt ||j
qW |jr| j!|j qf|j rf| j!|j qfW q0W t"st#st$r8t%tdrd| j t jtj n,t&rP| j t jtj' nt(rd| j t jd d S )NrO r r AF_LINKrM )rO r rY ))r/ net_if_addrs net_if_statsrc socketZAF_INETZAF_INET6r itemsrk r r6 rT Zfamilyrw addressZnetmasktypeZ broadcastr, r version_infor IntEnumisup
contextlibclosingZbindZ getaddrinfoZ SOCK_STREAMZ
AI_PASSIVEZptpr rC r r r
r^ r Z AF_PACKETr )r" nicsZ nic_statsZfamiliesZnicZaddrsaddrsr@ ZafZsocktypeprotoZ canonnameZsaZipr# r# r$ test_net_if_addrsA sV
z TestSystemAPIs.test_net_if_addrsc
C sp t rdtjdd d d fg}nd g}tjd|d8}tj d d }t rT| j|jd n| j|jd W d Q R X d S ) Nem1z06:3d:29rM 06-3d-29z psutil._psplatform.net_if_addrs)r r z06:3d:29:00:00:00z06-3d-29-00-00-00rY )r rY r NNN)r r/ r r r5 r r6 r )r" r rG r r# r# r$ test_net_if_addrs_mac_null_bytes} s
z/TestSystemAPIs.test_net_if_addrs_mac_null_byteszunreliable on TRAVISc C s t j }t jt jt jf}xh|j D ]\\}}| j|t |\}}}}| j|t | j || | j || | j
|d | j
|d q"W d S )Nr ) r/ r ZNIC_DUPLEX_FULLZNIC_DUPLEX_HALFZNIC_DUPLEX_UNKNOWNr rk r boolr, rD ) r" r Z all_duplexesrz Zstatsr ZduplexZspeedZmtur# r# r$ test_net_if_stats s z TestSystemAPIs.test_net_if_statsz/proc/diskstatsz3/proc/diskstats not available on this linux versionNzunreliable on APPVEYORc s fdd}t jdd}|| t jdd} jt|tt| xV|D ]N}||| trJ|d j rJx |d j r|d d }qlW j||j qJW d S )
Nc s j | d | j j | d | j j | d | j j | d | j tpNtsƈ j | d | j j | d | j t r j | d | j
j | d | j j | d | j nt
rƈ j | d | j x| jD ]}qW d S )
Nr rM rR rO r r r r )r6 Z
read_countZ write_countZ
read_bytesZ write_bytesr r Z read_timeZ
write_timer Zread_merged_countZwrite_merged_countZ busy_timer ru )r rz )r" r# r$ r s z:TestSystemAPIs.test_disk_io_counters..check_ntupleF)perdiskTrM rY rY rY ) r/ disk_io_countersr6 rT rc r isdigitr4 rA )r" r r r r# )r" r$ test_disk_io_counters s
z$TestSystemAPIs.test_disk_io_countersc C sD t jdi d,}| jtjdd | jtjddi W d Q R X d S )Nz#psutil._psplatform.disk_io_counters)r F)r T)r r5 rC r/ r r6 )r" rG r# r# r$ test_disk_io_counters_no_disks s
z-TestSystemAPIs.test_disk_io_counters_no_disksz unreliable on APPVEYOR or TRAVISc C s t j }| j|g x|D ]}| j|jt | j|jttd f |jd k rb| j|jttd f |j |j t j j
|j t st
r| j|j qt j|j qW d S )N)r/ usersr rk rz r Zterminalr hostdatetimeZ
fromtimestampZstartedr r rC r' r1 )r" r userr# r# r$
test_users s
zTestSystemAPIs.test_usersc C sZ t j }| j|jd x>|jD ]4}t||}| j|d t r |dkr | j|d q W d S )N ctx_switches
interruptssoft_interruptssyscallsr )r r r r )r r )r/ Z cpu_statsr6 ru rv rD r rm )r" Zinfosrz r{ r# r# r$ test_cpu_stats s
z TestSystemAPIs.test_cpu_statsz not suportedc sT fdd}t jdd}tr&| r&d S |t jddg trP jt|t j d S )Nc sh xb| D ]Z} j |jd j|j|j x6|jD ],}t||} j|ttt f j
|d q0W qW d S )Ncurrentminr r )r r r ) r6 ru r r r rv rk rw r rl rD )r r rz r{ )r" r# r$ check_ls s
z.TestSystemAPIs.test_cpu_freq..check_lsT)r F)r/ Zcpu_freqr r r6 rT r )r" r r r# )r" r$
test_cpu_freq s
z TestSystemAPIs.test_cpu_freqc C s8 ddddddddd g }x"|D ]}| j tt|t|d
q W tjd kr|jd d tjj krj|jd nd
tjj kr| j
tj tj tj
gjdd |jd |jd |jd |jd nBdtjj ksdtjj kr|jd ndtjj kr|jd n
|jd x$|D ] }| jtt|d|d
qW d S )Nr r r r r r r r r
)r posixlinuxZbsdTrM sunossolarisdarwinF)rk rv r/ r r- rz remover platformr r6 r r r countrF )r" namesrz r# r# r$ test_os_constants s.
z TestSystemAPIs.test_os_constantsz
not supportedc C s t j }x|j D ]x\}}| j|t xb|D ]Z}| j|jt |jd k rV| j|jd |jd k rn| j|jd |j d k r,| j|j d q,W qW d S )Nr )
r/ sensors_temperaturesr rk r labelr rD highcritical)r" tempsrz entriesentryr# r# r$ test_sensors_temperatures) s
z(TestSystemAPIs.test_sensors_temperaturesc
C sf ddgi}t jd|dD}tjdd d d
}| j|jd | j|jd | j|jd
W d Q R X d S )NZcoretempr I@ N@ Q@z'psutil._psplatform.sensors_temperatures)r T)Z
fahrenheitr g ^@g a@g c@)r r r r )r r5 r/ r r6 r r r )r" drG r r# r# r$ #test_sensors_temperatures_fahreneit7 s
z2TestSystemAPIs.test_sensors_temperatures_fahreneitz
no batteryc C sp t j }| j|jd | j|jd |jt jt jfkrF| j|jd n|jt jkr^| j|j | j
|j t d S )Nr r ) r/ Zsensors_batteryrD rs r ZsecsleftZPOWER_TIME_UNKNOWNZPOWER_TIME_UNLIMITEDrd Z
power_pluggedrk r )r" r r# r# r$ test_sensors_batteryC s
z#TestSystemAPIs.test_sensors_batteryc C sj t j }x\|j D ]P\}}| j|t x:|D ]2}| j|jt | j|jttf | j |jd q,W qW d S )Nr )
r/ Z sensors_fansr rk r r r rw r rD )r" Zfansrz r r r# r# r$ test_sensors_fansQ s
z TestSystemAPIs.test_sensors_fans)C__name__
__module__ __qualname____doc__r% r& r< rI ri rj rn r ZskipIfr rr r| r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r- r r r
r/ r r r r r r r r
r r r r! r r r" r r# r# r# r# r$ r! ; sh 7
!
> <#
%
r! __main__)2r' r r r r- r r ra r r r r[ r/ r r r r r r r r r
r Zpsutil._compatr Z psutil.testsr
r r r r r r r r r r r r r r r r r r r ZTestCaser! r$ r r# r# r# r$ sh '
PK ! &g[ * __pycache__/test_misc.cpython-36.opt-1.pycnu [ 3
JZ @ s| d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl
m Z ddl
m
Z
ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddlm%Z% ddlm&Z& dd lm'Z' dd lm(Z( dd lm)Z) dd lm*Z* dd lm+Z+ dd!lm,Z, dd"lm-Z- dd#lm.Z. dd$lm/Z/ dd%lm0Z0 dd&lm1Z1 dd'lm2Z2 dd(lm3Z3 dd)lm4Z4 dd*lm5Z5 dd+lm6Z6 dd,lm7Z7 dd-lm8Z8 dd.lm9Z9 dd/lm:Z: dd0lm;Z; dd1lmej?d4d5Z@G d6d7 d7e8j=ZAe8jBe6d8e8jBe7oejCjDe2 d9G d:d; d;e8j=ZEG dd? d?e8j=ZGG d@dA dAe8j=ZHG dBdC dCe8j=ZIG dDdE dEe8j=ZJG dFdG dGe8j=ZKeLdHkrxe0eM dS )Iz
Miscellaneous tests.
N)LINUX)POSIX)WINDOWS)memoize)memoize_when_activated)
supports_ipv6) wrap_numbers)PY3)APPVEYOR) bind_socket)bind_unix_socket)
call_until)chdir)create_proc_children_pair)create_sockets)create_zombie_proc)DEVNULL)
get_free_port)get_test_subprocess) HAS_BATTERY)HAS_CONNECTIONS_UNIX)HAS_MEMORY_FULL_INFO)HAS_MEMORY_MAPS)HAS_SENSORS_BATTERY)HAS_SENSORS_FANS)HAS_SENSORS_TEMPERATURES)import_module_by_path)
is_namedtuple)mock)
PYTHON_EXE)
reap_children)
reload_module)retry)ROOT_DIR)run_test_module_by_name) safe_rmpath) SCRIPTS_DIR)sh)tcp_socketpair)TESTFN)TOX)TRAVIS)unittest)unix_socket_path)unix_socketpair)
wait_for_file) wait_for_pidc @ s e Zd ZefddZdd ZefddZefddZefd d
Zefd d Z d
d Z
dd Z dd Z dd Z
dd Zdd Zdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)S )*TestMiscc C sn t j }||}| jd| | jd|j | | jd| | j|j | tjjt jdt jt j
d@ t j }||}| jd|j | | jd| | j d| W d Q R X tjjt jdt j t j
d@ t j }||}| jd|j | | jd| | j d| W d Q R X tjjt jdt j
t j
d4 t j }||}| jd|j | | j d| W d Q R X d S )Nzpsutil.Processzpid=%szname=name) side_effectZzombieZ
terminated)psutilProcessassertInpidr2 r patchobject
ZombieProcessosgetpid assertNotIn
NoSuchProcess AccessDenied)selffuncpr rD !/usr/lib64/python3.6/test_misc.pytest_process__repr__O s4 z TestMisc.test_process__repr__c C s | j td d S )N)rA )rF str)r@ rD rD rE test_process__str__k s z TestMisc.test_process__str__c C sN | j ttjdd | j ttjdddd | j ttjdddd d S )NiA z7psutil.NoSuchProcess process no longer exists (pid=321)foo)r2 zCpsutil.NoSuchProcess process no longer exists (pid=321, name='foo'))msgzpsutil.NoSuchProcess foo) assertEqualreprr4 r> )r@ rA rD rD rE test_no_such_process__repr__n s z%TestMisc.test_no_such_process__repr__c C sj | j ttjdd | j ttjdddd | j ttjddddd | j ttjddd d
d S ) NiA zEpsutil.ZombieProcess process still exists but it's a zombie (pid=321)rI )r2 zQpsutil.ZombieProcess process still exists but it's a zombie (pid=321, name='foo') )r2 ppidzYpsutil.ZombieProcess process still exists but it's a zombie (pid=321, name='foo', ppid=1))rJ zpsutil.ZombieProcess foo)rK rL r4 r: )r@ rA rD rD rE test_zombie_process__repr__z s z$TestMisc.test_zombie_process__repr__c C sN | j ttjdd | j ttjdddd | j ttjdddd d S )NiA z psutil.AccessDenied (pid=321)rI )r2 z)psutil.AccessDenied (pid=321, name='foo'))rJ zpsutil.AccessDenied foo)rK rL r4 r? )r@ rA rD rD rE test_access_denied__repr__ s z#TestMisc.test_access_denied__repr__c C sP | j ttjdd | j ttjdddd | j ttjddddd d S ) NiA z/psutil.TimeoutExpired timeout after 321 secondso )r7 z9psutil.TimeoutExpired timeout after 321 seconds (pid=111)rI )r7 r2 zEpsutil.TimeoutExpired timeout after 321 seconds (pid=111, name='foo'))rK rL r4 ZTimeoutExpired)r@ rA rD rD rE test_timeout_expired__repr__ s z%TestMisc.test_timeout_expired__repr__c C s> t j }t j }| j|| d|_| j|| | j|d d S )Nr rI )r r )r4 r5 rK Z_identassertNotEqual)r@ p1p2rD rD rE test_process__eq__ s zTestMisc.test_process__eq__c C s( t tj tj g}| jt|d d S )NrN )setr4 r5 rK len)r@ srD rD rE test_process__hash__ s z TestMisc.test_process__hash__c C s t t}x|D ]~}|d
kr q|jd
sy t| W q tk
r |tjkrtt|}|d kr`w|jd k rd |jj kr| j d | Y qX qW xtjD ]}| j
|| qW d S )Ncallableerror
namedtupletestslongtestNUM_CPUS BOOT_TIME TOTAL_PHYMEM_Z
deprecatedz%r not in psutil.__all__) r\ r] r^ r_ r` ra rb rc rd ) dirr4
startswith
__import__ ImportError__all__getattr__doc__lowerfailr6 )r@ Z
dir_psutilr2 ZfunrD rD rE test__all__ s&
zTestMisc.test__all__c C s$ | j djdd tjD tj d S )N.c S s g | ] }t |qS rD )rG ).0xrD rD rE
s z)TestMisc.test_version..)rK joinr4 version_info __version__)r@ rD rD rE test_version s zTestMisc.test_versionc C s" t j }d|_| jd|j d S )N1rI )r4 r5 rI r= as_dict)r@ rB rD rD rE !test_process_as_dict_no_new_names s z*TestMisc.test_process_as_dict_no_new_namesc s t fdd}g x:tdD ].}| }f i f}| j|| | jt d q W x.foo rN )barr z
foo docstring)rN )rN )r rangerK rY cache_clearrl )r@ rI rr retZexpectedrD )r~ rE test_memoize s. zTestMisc.test_memoizec s G fddd}| }g |j |j | jt d g |j j |j |j | jt d g |j j |j |j | jt d d S )Nc s e Zd Ze fddZdS )z1TestMisc.test_memoize_when_activated..Fooc s j d d S )N)r{ )r@ )r~ rD rE rI s z5TestMisc.test_memoize_when_activated..Foo.fooN)__name__
__module__ __qualname__r rI rD )r~ rD rE Foo s r r rN )rI rK rY Zcache_activateZcache_deactivate)r@ r frD )r~ rE test_memoize_when_activated s
z$TestMisc.test_memoize_when_activatedc C s ddl m} dd }| j|d|ddi | j|d|dd|d d
i | j|d |dd|d d i | j|d
|dd|d d
i | j|d|ddi | j|d|ddi | j|d|ddi d S )Nr )parse_environ_blockc S s t r | j S | S )N)r upper)rZ rD rD rE k s z,TestMisc.test_parse_environ_block..kza=1 arx z a=1 b=2 b2za=1 b= z
a=1 b=2 c=3 zxxx a=1 z a=1 =b=2 za=1 b=2)psutil._commonr rK )r@ r r rD rD rE test_parse_environ_block s
z!TestMisc.test_parse_environ_blockc C s | j tj t rtjd}d|_tj W d Q R X tj tjdtjd}W d Q R X tj tjdtjd}tj W d Q R X tj tjdtjd}tj W d Q R X n0| j t
tjtj tj }|j
d W d Q R X d S ) Nzpsutil._common.socketFz psutil._common.socket.socket)r3 z!psutil._common.socket.socket.bind::1r )r r )
addCleanupr r r r8 Zhas_ipv6socketr] Zgaierror assertRaises ExceptionAF_INET6 SOCK_STREAMZbind)r@ rZ sockrD rD rE test_supports_ipv6% s.
zTestMisc.test_supports_ipv6c C s ddl m} tjjt}tjdtt j
dd | j t|| W d Q R X tjdtt j dd | j t|| W d Q R X tjdtt j
dd W d Q R X tjddd W d Q R X d S ) Nr )
isfile_strictzpsutil._common.os.statrI )r3 zpsutil._common.stat.S_ISREGF) return_value)r r r; pathabspath__file__r r8 OSErrorerrnoZEPERMr ZEACCESEINVAL)r@ r Z this_filerD rD rE test_isfile_strictE s
zTestMisc.test_isfile_strictc s fdd}|t j j |t j |t j |t j |t jdd |t j trpt j
j d rpnt s|t j
|t j |t jt j |t j d S )Nc s< t d k rt jt j| tj| }tj|} j| | d S )N)jsonloadsdumpspicklerK )r r r )r@ rD rE checkW s
z*TestMisc.test_serialization..checkr )intervalz/proc/diskstats)r4 r5 ry Zvirtual_memoryZ swap_memoryZ cpu_timesZcpu_times_percentnet_io_countersr r; r existsr
disk_io_countersZdisk_partitionsZ
disk_usagegetcwdusers)r@ r rD )r@ rE test_serializationV s zTestMisc.test_serializationc C sV t jjtd}tr*t jj| r*| jdS t|}| jt |j
| j |j t
j d S )Nzsetup.pyzcan't find setup.py)r; r rt r# r+ r ZskipTestr r
SystemExitZsetuprK Z get_versionr4 rv )r@ Zsetup_pymodulerD rD rE test_setup_scriptm s
zTestMisc.test_setup_scriptc C s t jjtjdtjd}tj W d Q R X t jjtjdtjdd}tj W d Q R X t jjtjdtd$}| jt tj W d Q R X W d Q R X d S )NZ create_time)r3 rN ) r r8 r9 r4 r5 r? r:
ValueErrorr )r@ methrD rD rE test_ad_on_process_creationu s
z$TestMisc.test_ad_on_process_creationc C sR t jddd: | jt}tt W d Q R X | jdt|jj W d Q R X d S )Nz psutil._psplatform.cext.versionz0.0.0)r zversion conflict)
r r8 r ri r! r4 r6 rG exceptionrm )r@ cmrD rD rE test_sanity_version_check s
z"TestMisc.test_sanity_version_checkN)r r r rL rF rH rM rP rQ rS rW r[ ro rw rz r r r r r r r r r rD rD rD rE r1 M s( # r1 rI za b cc @ s e Zd Zdd ZeZdd Zdd Zdd Zd d
Zd d Z d
d Z
dd Z dd Z dd Z
dd Zdd Zdd Zejej pej dd d Zd S ) TestWrapNumbersc C s t j d S )N)r r )r@ rD rD rE setUp s zTestWrapNumbers.setUpc C s& dt dddi}| jt|d| d S )Ndisk1 disk_io)ntrK r )r@ inputrD rD rE test_first_call s z TestWrapNumbers.test_first_callc C s8 dt dddi}| jt|d| | jt|d| d S )Nr r r )r rK r )r@ r rD rD rE test_input_hasnt_changed s z(TestWrapNumbers.test_input_hasnt_changedc C s dt dddi}| jt|d| dt dddi}| jt|d| dt dddi}| jt|d| dt dddi}| jt|d| d S ) Nr r r
)r rK r )r@ r rD rD rE test_increase_but_no_wrap s z)TestWrapNumbers.test_increase_but_no_wrapc C s dt dddi}| jt|d| dt dddi}| jt|ddt dddi dt dddi}| jt|ddt dddi dt dddi}| jt|ddt dddi dt dddi}| jt|ddt ddd i dt dddi}| jt|ddt ddd i dt d
ddi}| jt|ddt d dd i dt d ddi}| jt|ddt ddd i dt d ddi}| jt|ddt ddd i d S )
Nr d r r n Z r 2 ( )r rK r )r@ r rD rD rE test_wrap s4 zTestWrapNumbers.test_wrapc C st dt dddi}| jt|d| t dddt dddd}| jt|d| dt dddi}| jt|d| d S )Nr r r )r disk2 )r rK r )r@ r rD rD rE test_changing_keys s
z"TestWrapNumbers.test_changing_keysc C s. t dddt dddd}| jt|d| t dddt dddd}| jt|dt dddt dddd dt dddi}| jt|d| t dddt dddd}| jt|d| t dddt dddd}| jt|d| t dddt dddd}| jt|dt dddt dddd d S )Nr r )r r r r r r )r rK r )r@ r rD rD rE test_changing_keys_w_wrap s*
z)TestWrapNumbers.test_changing_keys_w_wrapc C sb d'd(d)d*d"}| j t|d#| | j t|d#| d+d,d-d.d"}t|d#}| j |d% d d& d S )/N, # R ȷ r tU r r 6 $ N r r U " r 4 \ )nvme0n1Z nvme0n1p1Z nvme0n1p2Z nvme0n1p3r r r i ) r r r r r r r r r ) r r r r r r r r r ) r r r r r r r r r ) r r r r r r r r r ) r r r r r r r r r ) r r r r r r r r r ) r r r r r r r r r ) r r r r r r r r r )rK r )r@ doutrD rD rE test_real_data s
z TestWrapNumbers.test_real_datac C sb dt dddi}t|d tj }| j|d d|i | j|d di i | j|d di i d S )Nr r r r rN r )r r
cache_inforK )r@ r cacherD rD rE test_cache_first_call s
z%TestWrapNumbers.test_cache_first_callc C s dt dddi}t|d dt dddi}t|d tj }| j|d d|i | j|d dddd dd
dii | j|d di i d S ) Nr r r r r rN r )r r )r rN )r r )r r r rK )r@ r r rD rD rE test_cache_call_twice s
z%TestWrapNumbers.test_cache_call_twicec s dt dddi}t|d dt dddi}t|d tj } j|d d|i j|d dd
dddddii j|d ddtdgii fdd }dt dddi}t|d tj } j|d d|i | dt ddd
i}t|d tj } j|d d|i | dt ddd i}t|d tj } j|d d|i j|d ddddddd ii j|d ddtdgii d S )Nr r r r r rN r c sJ t j } j| d dddddd dii j| d ddtd
gii d S ) NrN r r r r r )r r )r rN )r r )r r )r r rK rX )r )r@ rD rE assert_4 s
z0TestWrapNumbers.test_cache_wrap..assert_r r r )r r )r rN )r r )r r )r r )r rN )r r )r r )r r r rK rX )r@ r r r rD )r@ rE test_cache_wrap% s:
z TestWrapNumbers.test_cache_wrapc C s dt dddi}t|d t dddt dddd}t|d tj }| j|d d|i | j|d dd dd
dd dii | j|d di i d S ) Nr r r r )r r r rN r )r r )r rN )r r )r r r rK )r@ r r rD rD rE test_cache_changing_keysU s
z(TestWrapNumbers.test_cache_changing_keysc C s\ dt dddi}t|d t|d tjd | jtj i i i f tjd tjd d S )Nr r r z?!?)r r r rK r )r@ r rD rD rE test_cache_clearb s
z TestWrapNumbers.test_cache_clearzno disks or NICs availablec C s t j t j tj }x$|D ] }| jd| | jd| q W t jj tj }x$|D ] }| jd| | jd| qVW t jj tj }| j|i i i f d S )Nzpsutil.disk_io_counterszpsutil.net_io_counters) r4 r r r r r6 r r= rK )r@ Zcachesr rD rD rE test_cache_clear_public_apisk s
z,TestWrapNumbers.test_cache_clear_public_apisN)r r r r tearDownr r r r r r r r r r r r r, skipIfr4 r r r rD rD rD rE r s"
% 0
r zcan't test on TOXz can't locate scripts directoryc @ s e Zd ZdZedd Zed=ddZdd Zej e
d d
d Z d d
Z dd Z
dd Zdd Zej epxeoxej ddd Zdd Zdd Zdd Zej ed d d Zej e d d!d" Zej e d d#d$ Z d%d& Z d'd( Z d)d* Z d+d, Z d-d. Z!ej e" d/d0d1 Z#d2d3 Z$ej e% d ej ed d4d5 Z&ej e' d ej ed d6d7 Z(ej e) d ej e* d8d9d: Z+d;d< Z,dS )> TestScriptsz-Tests for scripts in the "scripts" directory.c O s dt jjt| } t| g}x|D ]}|j| q W yt|f|j }W n8 tk
r~ } z dt |krlt |S W Y d d }~X nX |S )Nz%sr? )
r; r rt r& r r{ r' strip RuntimeErrorrG )exer| r} cmdargr errrD rD rE
assert_stdout s
zTestScripts.assert_stdoutNc C sR t jjt| } tr"t| ddd}n
t| d}| |j }W d Q R X tj| d S )NZrtutf8)encoding) r; r rt r& r openreadastparse)r r| r srcrD rD rE
assert_syntax s
zTestScripts.assert_syntaxc C sZ t | }xLtjtD ]>}|jdrdtjj|d |kr| jdtjjt| qW d S )Nz.pyZtest_r z no test defined for %r script) rf r; listdirr& endswithr splitextrn rt )r@ Zmethsr2 rD rD rE
test_coverage s
zTestScripts.test_coveragez
POSIX onlyc C sT xNt jtD ]@}|jdr t jjt|}tjt j|tj @ s | j d| q W d S )Nz.pyz%r is not executable)
r; r r& r r rt statS_IXUSRST_MODErn )r@ r2 r rD rD rE test_executable s
zTestScripts.test_executablec C s | j d d S )Nz
disk_usage.py)r )r@ rD rD rE test_disk_usage s zTestScripts.test_disk_usagec C s | j d d S )Nzfree.py)r )r@ rD rD rE test_free s zTestScripts.test_freec C s | j d d S )Nz
meminfo.py)r )r@ rD rD rE test_meminfo s zTestScripts.test_meminfoc C s | j dttj d S )Nz procinfo.py)r rG r; r< )r@ rD rD rE
test_procinfo s zTestScripts.test_procinfoz unreliable on APPVEYOR or TRAVISc C s | j d d S )Nzwho.py)r )r@ rD rD rE test_who s zTestScripts.test_whoc C s | j d d S )Nzps.py)r )r@ rD rD rE test_ps s zTestScripts.test_psc C s | j d d S )Nz pstree.py)r )r@ rD rD rE test_pstree s zTestScripts.test_pstreec C s | j d d S )Nz
netstat.py)r )r@ rD rD rE test_netstat s zTestScripts.test_netstatzunreliable on TRAVISc C s | j d d S )Nz ifconfig.py)r )r@ rD rD rE
test_ifconfig s zTestScripts.test_ifconfigz
not supportedc C s | j dttj d S )Nzpmap.py)r rG r; r< )r@ rD rD rE test_pmap s zTestScripts.test_pmapc C s | j dtd d S )Nz procsmem.py)stderr)r r )r@ rD rD rE
test_procsmem s zTestScripts.test_procsmemc C s | j d d S )Nz
killall.py)r )r@ rD rD rE test_killall s zTestScripts.test_killallc C s | j d d S )Nz nettop.py)r )r@ rD rD rE test_nettop s zTestScripts.test_nettopc C s | j d d S )Nztop.py)r )r@ rD rD rE test_top s zTestScripts.test_topc C s | j d d S )Nziotop.py)r )r@ rD rD rE
test_iotop s zTestScripts.test_iotopc C s, | j dtj j }| jttj | d S )Nzpidof.py)r r4 r5 r2 r6 rG r; r< )r@ outputrD rD rE
test_pidof s zTestScripts.test_pidofz WINDOWS onlyc C s | j d d S )Nzwinservices.py)r )r@ rD rD rE test_winservices s z TestScripts.test_winservicesc C s | j d d S )Nzcpu_distribution.py)r )r@ rD rD rE test_cpu_distribution s z!TestScripts.test_cpu_distributionc C s | j d d S )Nztemperatures.py)r )r@ rD rD rE test_temperatures s z TestScripts.test_temperaturesc C s | j d d S )Nzfans.py)r )r@ rD rD rE test_fans s zTestScripts.test_fansz
no batteryc C s | j d d S )Nz
battery.py)r )r@ rD rD rE test_battery s zTestScripts.test_batteryc C s | j d d S )Nz
sensors.py)r )r@ rD rD rE test_sensors s zTestScripts.test_sensors)N)-r r r rl staticmethodr r r r, r r r r r r r r
r+ r4 r r r! r" r# r$ r r% r r' r( r) r* r+ r- r r. r/ r r0 r r1 r r r2 r3 rD rD rD rE r s@
r c @ sx e Zd Zejddd Zejddd Zejddd Zejddd Zejdd
d Z ejdd d
Z
dS )TestRetryDecoratorz
time.sleepc sF t ddd d fdd}ttd | j| d | j|jd d S )Nr rN )retriesr logfunc s x r j dd qW dS )NrN r )poprD )queuerD rE rI s z2TestRetryDecorator.test_retry_success..foor )r" listr rK
call_count)r@ sleeprI rD )r9 rE test_retry_success s z%TestRetryDecorator.test_retry_successc sD t ddd d fdd}ttd | jt| | j|jd d S )Nr rN )r6 r r7 c s x r j dd qW dS )NrN r )r8 rD )r9 rD rE rI & s z2TestRetryDecorator.test_retry_failure..foo )r" r: r r ZeroDivisionErrorrK r; )r@ r< rI rD )r9 rE test_retry_failure" s z%TestRetryDecorator.test_retry_failurec C s2 t tdddd }| jt| | j|jd d S )NrN )r r c S s t d S )N) TypeErrorrD rD rD rE rI 3 s z2TestRetryDecorator.test_exception_arg..foor )r" r r rA rK r; )r@ r< rI rD rD rE test_exception_arg1 s z%TestRetryDecorator.test_exception_argc C s4 t dd d ddd }| jt| | j|jd d S )Nr )r6 r r7 c S s dd d S )NrN r rD rD rD rD rE rI > s z4TestRetryDecorator.test_no_interval_arg..foor )r" r r? rK r; )r@ r< rI rD rD rE test_no_interval_arg: s z'TestRetryDecorator.test_no_interval_argc C s4 t ddd ddd }| jt| | j|jd d S )Nr rN )r6 r r7 c S s dd d S )NrN r rD rD rD rD rE rI H s z0TestRetryDecorator.test_retries_arg..foo)r" r r? rK r; )r@ r< rI rD rD rE test_retries_argE s z#TestRetryDecorator.test_retries_argc C s | j ttddd d S )Nr rN )r6 Ztimeout)r r r" )r@ r< rD rD rE test_retries_and_timeout_argsO s z0TestRetryDecorator.test_retries_and_timeout_argsN) r r r r r8 r= r@ rB rC rD rE rD rD rD rE r5 s
r5 c @ sD e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z dS )TestSyncTestUtilsc C s t t d S )N)r% r) )r@ rD rD rE r V s zTestSyncTestUtils.tearDownc C sP t tj ttj d }tjdtdgd | j tj
t | W d Q R X d S )Ni zpsutil.tests.retry.__iter__r )r ) r0 r; r< maxr4 Zpidsr r8 iterr r> )r@ ZnopidrD rD rE test_wait_for_pidY s z#TestSyncTestUtils.test_wait_for_pidc C s, t td}|jd W d Q R X tt d S )NwrI )r r) writer/ )r@ r rD rD rE test_wait_for_file_ s z$TestSyncTestUtils.test_wait_for_filec C s& t td W d Q R X ttdd d S )NrJ T)empty)r r) r/ )r@ rD rD rE test_wait_for_file_emptye s
z*TestSyncTestUtils.test_wait_for_file_emptyc C s2 t jdtdgd | jttt W d Q R X d S )Nzpsutil.tests.retry.__iter__r )r )r r8 rH r IOErrorr/ r) )r@ rD rD rE test_wait_for_file_no_filek s z,TestSyncTestUtils.test_wait_for_file_no_filec C s0 t td}|jd W d Q R X ttdd d S )NrJ rI F)delete)r r) rK r/ )r@ r rD rD rE test_wait_for_file_no_deleteo s z.TestSyncTestUtils.test_wait_for_file_no_deletec C s t dd d}| j|d d S )Nc S s dS )NrN rD rD rD rD rE v s z3TestSyncTestUtils.test_call_until..zret == 1rN )r
rK )r@ r rD rD rE test_call_untilu s z!TestSyncTestUtils.test_call_untilN)
r r r r rI rL rN rP rR rT rD rD rD rE rF T s rF c @ s( e Zd Zdd ZeZdd Zdd ZdS )TestFSTestUtilsc C s t t d S )N)r% r) )r@ rD rD rE r | s zTestFSTestUtils.setUpc C st t tdj tt tt tjt tt tjdtt j
dd$}| j t tt W d Q R X W d Q R X d S )NrJ zpsutil.tests.os.statr )r3 ) r r) closer% r; mkdirr r8 r r r r )r@ mrD rD rE test_safe_rmpath s
z TestFSTestUtils.test_safe_rmpathc C sT t j }t jt tt | jt j t jj|t W d Q R X | jt j | d S )N)r; r rW r) r rK r rt )r@ baserD rD rE
test_chdir s
$zTestFSTestUtils.test_chdirN)r r r r r rY r[ rD rD rD rE rU z s rU c @ s2 e Zd Zdd Zdd Zeje ddd ZdS ) TestProcessUtilsc C s t }tj|j}t d S )N)r r4 r5 r7 r )r@ ZsubprB rD rD rE test_reap_children s z#TestProcessUtils.test_reap_childrenc C s t \}}| j|j|j tj jdd}| jt|d | j|| | j|| | j|j t
j | j|j |j t d S )NT) recursiver )
r rT r7 r4 r5 childrenrK rY r6 rO r; r< r )r@ rU rV r_ rD rD rE test_create_proc_children_pair s
z/TestProcessUtils.test_create_proc_children_pairz
POSIX onlyc C s4 t }| jtdd tj|}| j|j tj d S )NT)r^ )r r r r4 r5 rK ZstatusZ
STATUS_ZOMBIE)r@ ZzpidrB rD rD rE test_create_zombie_proc s
z(TestProcessUtils.test_create_zombie_procN) r r r r] r` r, r r ra rD rD rD rE r\ s r\ c @ sP e Zd Zdd Zeje ddd Zdd Zeje ddd Z d
d Z
d S )
TestNetUtilsc
C s> t }tjtd|fd}| j|j d | W d Q R X d S )Nr )addrrN )r
contextlibclosingr rK getsockname)r@ ZportrZ rD rD rE r s zTestNetUtils.bind_socketz
POSIX onlyc C s t T}t|}tj|6 | j|jtj | j|jtj | j|j
| W d Q R X W d Q R X t :}t|tj d}tj| | j|jtj W d Q R X W d Q R X d S )N)type) r- r rd re rK familyr AF_UNIXrg r rf
SOCK_DGRAM)r@ r2 r rD rD rE test_bind_unix_socket s z"TestNetUtils.test_bind_unix_socketc C s| dt f}ttj|d\}}tj|L tj|6 | j|j | | j|j | | j |j | W d Q R X W d Q R X d S )Nz 127.0.0.1)rc )
r r( r AF_INETrd re rK rf getpeernamerT )r@ rc serverclientrD rD rE tcp_tcp_socketpair s
z TestNetUtils.tcp_tcp_socketpairc C s t j }|j }t v}t|\}}zP| j|j | d | jt|jddd | j|j | | j|j | W d |j
|j
X W d Q R X d S )Nr Zunix)Zkind) r4 r5 num_fdsr- r. rK rY Z connectionsrf rm rV )r@ rB rq r2 rn ro rD rD rE test_unix_socketpair s z!TestNetUtils.test_unix_socketpairc C s t }tjt}tjt}x:|D ]2}||j d7 < ||jtjtj d7 < q"W | j |tj
d t r| j |tj d t
rtr| j |tj d | j |tj d | j |tj d W d Q R X d S )NrN r )r collections defaultdictintrh Z
getsockoptr Z
SOL_SOCKETZSO_TYPEZassertGreaterEqualrl r r r r ri r rj )r@ ZsocksZfamstypesrZ rD rD rE test_create_sockets s
z TestNetUtils.test_create_socketsN) r r r r r, r r rk rp rr rw rD rD rD rE rb s
rb c @ s e Zd Zdd ZdS )TestOtherUtilsc C s d S )NrD )r@ rD rD rE test_is_namedtuple s z!TestOtherUtils.test_is_namedtupleN)r r r ry rD rD rD rE rx s rx __main__)Nrl r rs rd r r r; r r r r4 r r r r r r r r Zpsutil._compatr Z psutil.testsr
r r r
r r r r r r r r r r r r r r r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 ZTestCaser1 r^ r r r r r r r5 rF rU r\ rb rx r r rD rD rD rE s I p
C&!&E
PK ! + + - __pycache__/test_unicode.cpython-36.opt-1.pycnu [ 3
JZ[2 @ s d Z ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
Z
ddlm Z dd l m
Z
dd
l mZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! dd lm"Z" dd lm#Z# dd lm$Z$ dd lm%Z% dd lm&Z& ddlZddlZd!d" Z d#d$ Z'e
re"j(d%d& j)d%d'Z*ne"d( Z*G d)d* d*e+Z,e%j-e oe$d+e%j-ed,e%j-e'e# d-G d.d/ d/e,e%j.Z/e%j-e o*e$d+e%j-e'e* d0G d1d2 d2e,e%j.Z0e%j-e d3G d4d5 d5e%j.Z1G d6d7 d7e%j.Z2e3d8kre e4 dS )9a
Notes about unicode handling in psutil
======================================
In psutil these are the APIs returning or dealing with a string
('not tested' means they are not tested to deal with non-ASCII strings):
* Process.cmdline()
* Process.connections('unix')
* Process.cwd()
* Process.environ()
* Process.exe()
* Process.memory_maps()
* Process.name()
* Process.open_files()
* Process.username() (not tested)
* disk_io_counters() (not tested)
* disk_partitions() (not tested)
* disk_usage(str)
* net_connections('unix')
* net_if_addrs() (not tested)
* net_if_stats() (not tested)
* net_io_counters() (not tested)
* sensors_fans() (not tested)
* sensors_temperatures() (not tested)
* users() (not tested)
* WindowsService.binpath() (not tested)
* WindowsService.description() (not tested)
* WindowsService.display_name() (not tested)
* WindowsService.name() (not tested)
* WindowsService.status() (not tested)
* WindowsService.username() (not tested)
In here we create a unicode path with a funky non-ASCII name and (where
possible) make psutil return it back (e.g. on name(), exe(), open_files(),
etc.) and make sure that:
* psutil never crashes with UnicodeDecodeError
* the returned path matches
For a detailed explanation of how psutil handles unicode see:
- https://github.com/giampaolo/psutil/issues/1040
- http://psutil.readthedocs.io/#unicode
N)closing)BSD)OPENBSD)OSX)POSIX)WINDOWS)PY3)u)APPVEYOR)ASCII_FS)bind_unix_socket)chdir)copyload_shared_lib)
create_exe)get_test_subprocess)HAS_CONNECTIONS_UNIX) HAS_ENVIRON)HAS_MEMORY_MAPS)mock)
reap_children)run_test_module_by_name)
safe_mkdir) safe_rmpath)skip_on_access_denied)TESTFILE_PREFIX)TESTFN)TESTFN_UNICODE)TRAVIS)unittest)unix_socket_pathc C s8 t r,yt| S tk
r( tj Y q4X nt| S d S )N)r
_safe_rmpathZ WindowsError traceback print_exc)path r$ $/usr/lib64/python3.6/test_unicode.pyr \ s r c C sT t rdS z>y t| t| t| gd W n tk
r> dS X dS W dt X dS )z`Return True if both the fs and the subprocess module can
deal with a unicode file name.
T)cmdFN)r r r r UnicodeEncodeErrorr )namer$ r$ r% subprocess_supports_unicodep s r) utf8s fsurrogateescapeu fÀc @ s e Zd ZdZedd Zedd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
eje ddd Zeje deje de dd Zdd Zeje d eje d d d ZdS ) _BaseFSAPIsTestsNc C s t | j t| j d S )N)r
funky_namer )clsr$ r$ r%
setUpClass s
z_BaseFSAPIsTests.setUpClassc C s t t| j d S )N)r r r- )r. r$ r$ r%
tearDownClass s z _BaseFSAPIsTests.tearDownClassc C s
t d S )N)r )selfr$ r$ r% tearDown s z_BaseFSAPIsTests.tearDownc C s t dd S )Nz must be implemented in subclass)NotImplementedError)r1 r$ r$ r% expect_exact_path_match s z(_BaseFSAPIsTests.expect_exact_path_matchc C sH t | jgd}tj|j}|j }| j|t | j rD| j || j d S )N)r& )
r r- psutilProcesspidexeassertIsInstancestrr4 assertEqual)r1 subppr8 r$ r$ r%
test_proc_exe s z _BaseFSAPIsTests.test_proc_exec C s t | jgd}trHtjdtjtj d}tj |j
j }W d Q R X ntj |j
j }| j |t
| j r| j|tjj| j d S )N)r& z psutil._psplatform.cext.proc_exe) side_effect)r r- r r patchr5 AccessDeniedosgetpidr6 r7 r( r9 r: r4 r; r# basename)r1 r< mr( r$ r$ r% test_proc_name s z _BaseFSAPIsTests.test_proc_namec C sX t | jgd}tj|j}|j }x|D ]}| j|t q(W | j rT| j || jg d S )N)r& )
r r- r5 r6 r7 cmdliner9 r: r4 r; )r1 r< r= rG partr$ r$ r% test_proc_cmdline s
z"_BaseFSAPIsTests.test_proc_cmdlinec
C sj | j d }| jt| t| t| tj }|j }W d Q R X | j|j t | j
rf| j || d S )N2) r-
addCleanupr r r
r5 r6 cwdr9 r: r4 r; )r1 dnamer= rL r$ r$ r%
test_proc_cwd s
z _BaseFSAPIsTests.test_proc_cwdc C s t j }t|j }t| jd t|j }W d Q R X || j j}| j|t t
rf| rf| j dS | j r| j
tjj|tjj| j d S )Nrbzopen_files on BSD is broken)r5 r6 setZ
open_filesopenr- popr# r9 r: r ZskipTestr4 r; rB normcase)r1 r= startnewr# r$ r$ r% test_proc_open_files s
z%_BaseFSAPIsTests.test_proc_open_filesz
POSIX onlyc C s t jj| j}t|d}y t|}W n& tk
rL tr> n
tj dY nX t
|8 t j j
dd }| j|jt ts| j|j| W d Q R X W d Q R X d S )N)suffixz
not supportedunixr )rB r# rD r- r r r' r r SkipTestr r5 r6 Z connectionsr9 laddrr: r r; )r1 rW r( sockconnr$ r$ r% test_proc_connections s
z&_BaseFSAPIsTests.test_proc_connectionszcan't list UNIX socketsc C s dd }t jj| j}t|d}y t|}W n& tk
rT trF n
tj dY nX t
|: t j dd}t
s||}| j|jt | j|j| W d Q R X W d Q R X d S )Nc S s2 x$| D ] }t jj|jjtr|S qW tdd S )Nzconnection not found)rB r# rD rZ
startswithr
ValueError)consr\ r$ r$ r% find_sock s
z8_BaseFSAPIsTests.test_net_connections..find_sock)rW z
not supportedrX )Zkind)rB r# rD r- r r r' r r rY r r5 Znet_connectionsr r9 rZ r: r; )r1 ra rW r( r[ r` r\ r$ r$ r% test_net_connections s
z%_BaseFSAPIsTests.test_net_connectionsc C s, | j d }| jt| t| tj| d S )NrJ )r- rK r r r5 Z
disk_usage)r1 rM r$ r$ r% test_disk_usage s
z _BaseFSAPIsTests.test_disk_usagez
not supportedz&ctypes does not support unicode on PY2c sv t | jd`}dd fddtj j D }dd |D }| j || x|D ]}| j|t qTW W d Q R X d S )N)Z
dst_prefixc S s t jjt jj| S )N)rB r# realpathrS )r= r$ r$ r% normpath s z3_BaseFSAPIsTests.test_memory_maps..normpathc s g | ]} |j qS r$ )r# ).0x)re r$ r%
s z5_BaseFSAPIsTests.test_memory_maps..c S s g | ]}t |kr|qS r$ )r )rf rg r$ r$ r% rh s )r r- r5 r6 Z memory_mapsZassertInr9 r: )r1 Z
funky_pathZlibpathsr# r$ )re r% test_memory_maps s
z!_BaseFSAPIsTests.test_memory_maps)__name__
__module__ __qualname__r- classmethodr/ r0 r2 r4 r> rF rI rN rV r skipIfr r] r r rb rc r r ri r$ r$ r$ r% r, s" r, zunreliable on TRAVISzASCII fsz"subprocess can't deal with unicodec @ s e Zd ZdZeZedd ZdS )
TestFSAPIsz1Test FS APIs with a funky, valid, UTF8 path name.c
C sN t rdS t| jtrdntd}tj tjd | jtj |kS Q R X d S )NT.ignore)
r
isinstancer- r: r warningscatch_warnings simplefilterrB listdir)r. herer$ r$ r% r4 ( s
z"TestFSAPIs.expect_exact_path_matchN)rj rk rl __doc__r r- rm r4 r$ r$ r$ r% ro s ro z*subprocess can't deal with invalid unicodec @ s e Zd ZdZeZedd ZdS )TestFSAPIsWithInvalidPathz-Test FS APIs with a funky, invalid path name.c C s dS )NTr$ )r. r$ r$ r% r4 < s z1TestFSAPIsWithInvalidPath.expect_exact_path_matchN)rj rk rl rx INVALID_NAMEr- rm r4 r$ r$ r$ r% ry 5 s ry z WINDOWS onlyc @ s e Zd Zdd ZdS )TestWinProcessNamec
C s< t jdtjtj d}| jtj j t W d Q R X d S )Nz psutil._psplatform.cext.proc_exe)r? )
r r@ r5 rA rB rC r9 r6 r( r: )r1 rE r$ r$ r% test_name_typeE s z!TestWinProcessName.test_name_typeN)rj rk rl r| r$ r$ r$ r% r{ B s r{ c @ s. e Zd ZdZdd Zeje ddd ZdS )
TestNonFSAPISz&Unicode tests for non fs-related APIs.c C s
t d S )N)r )r1 r$ r$ r% r2 W s zTestNonFSAPIS.tearDownz
not supportedc C s~ t jj }trtnd}||d< t|d}tj|j}|j }x,|j D ] \}}| j
|t | j
|t qFW | j |d | d S )N èZ FUNNY_ARG)env)
rB environcopyr r r r5 r6 r7 itemsr9 r: r; )r1 r Z funky_strZsprocr= kvr$ r$ r% test_proc_environZ s
z TestNonFSAPIS.test_proc_environN) rj rk rl rx r2 r rn r r r$ r$ r$ r% r} T s r} __main__)5rx rB r! rs
contextlibr r5 r r r r r Zpsutil._compatr r Z psutil.testsr
r r r
r r r r r r r r r r r r r r r r r r r r) encodedecoderz objectr, rn ZTestCasero ry r{ r} rj __file__r$ r$ r$ r% 4 sr
PK ! o o ' __pycache__/test_windows.cpython-36.pycnu [ 3
JZK @ s` d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl m
Z
ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ e j Z e jd y$ddl Z ddl Z ddl Z ddl Z W n$ e k
rD ej!dkr@ Y nX W dQ R X e j"j#Z#e j$d$kZ%dd Z&ej'e
dG dd dej(Z)ej'e
dG dd dej(Z*ej'e
dG dd dej(Z+ej'e
dG dd d ej(Z,ej'e
dG d d d ej(Z-ej'e
dG d d d ej(Z.ej'e
dG d!d" d"ej(Z/e0d#kr\ee1 dS )%zWindows specific tests. N)WINDOWS)callable)APPVEYOR)get_test_subprocess) HAS_BATTERY)mock)
reap_children)retry_before_failing)run_test_module_by_name)sh)unittestignorent c s fdd}|S )Nc st y | f||S t k
rn } zBddlm} |j|krDtjd d |jtjkr\tjd d W Y d d }~X nX d S )Nr )ACCESS_DENIED_SET)OSErrorZpsutil._pswindowsr errnopsutil AccessDeniedZESRCH
NoSuchProcess)selfargskwargserrr )fun $/usr/lib64/python3.6/test_windows.pywrapper5 s
z wrap_exceptions..wrapperr )r r r )r r wrap_exceptions4 s
r z WINDOWS onlyc @ s e Zd Zdd Zejdejkddd Zdd Z d d
Z
d d Z eje d
e
dd Ze
dd Zdd Zdd Zdd Zdd Zdd Zd S ) TestSystemAPIsc C sV t d}tjddj }x8|D ]0}d|jddj kr8q ||kr | jd| q W d S )Nz
ipconfig /allT)Zperniczpseudo-interface -z-%r nic wasn't found in 'ipconfig /all' output)r r Znet_io_counterskeysreplacelowerfail)r outZnicsZnicr r r test_nic_namesJ s
z TestSystemAPIs.test_nic_namesNUMBER_OF_PROCESSORSz-NUMBER_OF_PROCESSORS env var is not availablec C s" t tjd }| j|tj d S )Nr) )intosenviron assertEqualr cpu_count)r Znum_cpusr r r test_cpu_countT s z TestSystemAPIs.test_cpu_countc C s$ t j d }tj }| j|| d S )N )win32apiZ
GetSystemInfor r. r- )r sys_value psutil_valuer r r test_cpu_count_2Z s z TestSystemAPIs.test_cpu_count_2c C s@ t j }|j d }| j|jtj j | j|jtj j d S )Nr )
wmiWMIZWin32_Processorr- ZCurrentClockSpeedr Zcpu_freqZcurrentZ
MaxClockSpeedmax)r wprocr r r
test_cpu_freq_ s z TestSystemAPIs.test_cpu_freqc C s, t j j d }| jt|jtj j d S )Nr ) r5 r6 ZWin32_ComputerSystemr- r* ZTotalPhysicalMemoryr Zvirtual_memorytotal)r r8 r r r test_total_phymeme s z TestSystemAPIs.test_total_phymemz test not relieable on appveyorc C s: t j j }tdd |D }ttj }| j|| d S )Nc S s g | ]
}|j qS r ) ProcessId).0xr r r
| s z,TestSystemAPIs.test_pids..)r5 r6
Win32_Processsetr Zpidsr- )r r8 Zwmi_pidsZ psutil_pidsr r r test_pidsv s zTestSystemAPIs.test_pidsc C s t jdd}tj j }x|D ]}x|D ]}|jjdd|jkr(|jsHP yt j |j}W n4 t
k
r } z|j t j krzP n W Y d d }~X nX | j
|jt|j t|j}| j
|j| t|j| d
kr| jd|j|f P q(W | jdt| q W d S ) NT)all\
i zpsutil=%s, wmi=%szcan't find partition %si ( i )r disk_partitionsr5 r6 ZWin32_LogicalDiskZdevicer$ ZDeviceID
mountpoint
disk_usager r ENOENTr- r; r* ZSizeZ FreeSpacefreeabsr& repr)r Zps_partsZ wmi_partsZps_partZwmi_partZusager Zwmi_freer r r
test_disks s*
zTestSystemAPIs.test_disksc C sp xjt j D ]^}tj|j}t j|j}| j|d |jdd | j|d |jdd | j |j
|j|j q
W d S )Nr i )delta i i ) r rH r1 ZGetDiskFreeSpaceExrI rJ assertAlmostEqualrL r; r- Zused)r Zdiskr2 r3 r r r test_disk_usage s z TestSystemAPIs.test_disk_usagec C s> dd t j jdD }dd tjddD }| j|| d S )Nc S s$ g | ] }|r|j d r|d qS )zA:rE )
startswith)r> r? r r r r@ s z7TestSystemAPIs.test_disk_partitions..z\ c S s g | ]
}|j qS r )rI )r> r? r r r r@ s T)rD )r1 ZGetLogicalDriveStringssplitr rH r- )r r2 r3 r r r test_disk_partitions s z#TestSystemAPIs.test_disk_partitionsc C s` t tj }tj j }t }x$|D ] }|j|j |j|j q$W | j ||@ d||f d S )Nzno common entries in %s, %s)
rB cextZ net_if_statsr5 r6 ZWin32_NetworkAdapteraddNameZNetConnectionID
assertTrue)r Zps_namesZ wmi_adaptersZ wmi_namesZ wmi_adapterr r r test_net_if_stats s
z TestSystemAPIs.test_net_if_statsc C s^ t j j }|d jjdd }tjj|d}tjjtj }t
|| j }| j |d d S )Nr .z %Y%m%d%H%M%S )
r5 r6 ZWin32_OperatingSystemZLastBootUpTimerU datetimeZstrptimeZ
fromtimestampr boot_timerM Z
total_secondsZassertLessEqual)r Zwmi_osZ
wmi_btime_strZ wmi_btime_dtZ psutil_dtZdiffr r r test_boot_time s z TestSystemAPIs.test_boot_timec C s t jddd | jtj d W d Q R X t jddd | jtj d W d Q R X t jddd | jtj d W d Q R X t jddd | jtj d W d Q R X d S )Nz psutil._pswindows.cext.boot_timer0 ) return_value iM )r patchr- r r_ )r r r r test_boot_time_fluctuation s z)TestSystemAPIs.test_boot_time_fluctuationN)__name__
__module__ __qualname__r( r skipIfr+ r, r/ r4 r: r< r r rC rO rS rV r[ r` re r r r r r G s
r c @ s` e Zd Zdd Zeje ddd Zeje ddd Zdd Z d
d Z
d d
Z dd Z dS )TestSensorsBatteryc C s. t j d r | jtj n| jtj d S )NZSystemBatteriesPresent)r1 ZGetPwrCapabilitiesZassertIsNotNoner sensors_battery assertIsNone)r r r r test_has_battery s z#TestSensorsBattery.test_has_batteryz
no batteryc C s6 t j }|jdd }tj }| j|j|jdd d S )Nzselect * from Win32_Batteryr rQ )rP )r5 r6 queryr rk rR ZpercentZEstimatedChargeRemaining)r r8 battery_wmibattery_psutilr r r test_percent s z TestSensorsBattery.test_percentc C s6 t j }|jdd }tj }| j|j|jdk d S )Nzselect * from Win32_Batteryr r )r5 r6 rn r rk r- Z
power_pluggedZ
BatteryStatus)r r8 ro rp r r r test_power_plugged s
z%TestSensorsBattery.test_power_pluggedc C s6 t jddd }| jtj |js(tW d Q R X d S )Nz&psutil._pswindows.cext.sensors_batteryr )ra )r rs r r )r rd rl r rk calledAssertionError)r mr r r test_emulate_no_battery s
z*TestSensorsBattery.test_emulate_no_batteryc
C s< t jddd$}| jtj jtj |js.tW d Q R X d S )Nz&psutil._pswindows.cext.sensors_batteryrQ r )ra )rQ r r r ) r rd r- r rk secsleftPOWER_TIME_UNLIMITEDrt ru )r rv r r r test_emulate_power_connected s
z/TestSensorsBattery.test_emulate_power_connectedc
C s< t jddd$}| jtj jtj |js.tW d Q R X d S )Nz&psutil._pswindows.cext.sensors_batteryr )ra )r r{ r r ) r rd r- r rk rx ry rt ru )r rv r r r test_emulate_power_charging s
z.TestSensorsBattery.test_emulate_power_chargingc
C s< t jddd$}| jtj jtj |js.tW d Q R X d S )Nz&psutil._pswindows.cext.sensors_batteryr rQ )ra )r r r r} ) r rd r- r rk rx ZPOWER_TIME_UNKNOWNrt ru )r rv r r r test_emulate_secs_left_unknown s
z1TestSensorsBattery.test_emulate_secs_left_unknownN)
rf rg rh rm r ri r rq rr rw rz r| r~ r r r r rj s
rj c @ s e Zd Zedd Zedd Zdd Zdd Zd d
Zd d Z d
d Z
dd Z dd Z e
jejd+k ddd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*S ), TestProcessc C s t j| _d S )N)r pid)clsr r r
setUpClass s zTestProcess.setUpClassc C s
t d S )N)r )r r r r
tearDownClass s zTestProcess.tearDownClassc C s t jd}| jt j|j d S )Nr )r Process assertRaisesr kill)r pr r r
test_issue_24 s
zTestProcess.test_issue_24c C s t jd}| j|j d t| |j | j|j dk y|j d d \}}W n( t j k
r| t
j d d
krx Y nX | j|d k d S ) Nrb ZSystemg r rQ vistawin-7win7r )r r r ) r r r- namestrusernamerZ create_time memory_infor platformuname)r r rssvmsr r r test_special_pid s
z TestProcess.test_special_pidc C s" t j| j}| jt|jtj d S )N)r r r r
ValueError send_signalsignalSIGINT)r r r r r test_send_signal1 s z TestProcess.test_send_signalc C sN xHt j D ]<}y | jtjj|j |j W q
t jk
rD Y q
X q
W d S )N) r process_iterr- r+ pathbasenameexer Error)r r r r r test_exe5 s
zTestProcess.test_exec C sb t jtj }|j }tjtjtj tj }|j }| j
||d tj | | j
|j | d S )NrQ ) r r r+ getpid num_handlesr1 OpenProcesswin32conPROCESS_QUERY_INFORMATIONFALSEr- CloseHandle)r r Zbeforehandleafterr r r test_num_handles_increment< s
z&TestProcess.test_num_handles_incrementc
s fdd}t j| j}g }xtt jD ] jds( dkrBq(q(y(|| |j }|| |j }W n t jt jfk
r Y q(X ||kr(d ||f }|j| q(W |r| j ddj
| d S )Nc s, t | d }|d k r$t|r$| n| d S )N)getattrr )r attr)r r r callJ s z+TestProcess.test_handles_leak..call_ terminater suspendresumenicer waitchildrenas_dictmemory_info_exz@failure while processing Process.%s method (before=%s, after=%s)
)
r r r r r r r r r r ) r r r dirrT r r r appendr& join)r r r ZfailuresZnum1Znum2r& r )r r test_handles_leakF s,
z TestProcess.test_handles_leakc C s: x4t j D ](}y |j W q
t jk
r0 Y q
X q
W d S )N)r r r r )r r r r r test_name_always_availablej s
z&TestProcess.test_name_always_availabler z CTRL_* signals not supportedc C sb t jt j}|jtj |jtj |j |j | j
t j |jtj | j
t j |jtj d S )N) r r r r r r Z CTRL_C_EVENTZCTRL_BREAK_EVENTr r r r )r r r r r test_ctrl_signalss s z TestProcess.test_ctrl_signalsc
C s\ xVt j D ]J}y tjj|j }|j }W n t jt jfk
rF Y q
X | j || q
W d S )N)
r r r+ r r r r r r r- )r r abr r r test_compare_name_exe s z!TestProcess.test_compare_name_exec C s | j tj j tjtj d S )N)r- r r r r1 Z
GetUserNameExr ZNameSamCompatible)r r r r
test_username s zTestProcess.test_usernamec C s8 t jddtj j }djtj j }| j || d S )Nz +r! )
resubr1 ZGetCommandLinestripr r r cmdliner- )r r2 r3 r r r test_cmdline s zTestProcess.test_cmdlinec C sJ t jtjtjtj }| jt j| t j
|}t j j
}| j|| d S )N)r1 r r r r r+ r
addCleanupr win32processZGetPriorityClassr r r r- )r r r2 r3 r r r test_nice s
zTestProcess.test_nicec C s t jtjtj| j}| jt j| tj |}t
j | jj }| j
|d |j | j
|d |j | j
|d |j | j
|d |j | j
|d |j | j
|d |j | j
|d |j | j
|d |j | j
|j|j | j
|j|j d S ) NZPeakWorkingSetSizeWorkingSetSizeZQuotaPeakPagedPoolUsageZQuotaPagedPoolUsageZQuotaPeakNonPagedPoolUsageZQuotaNonPagedPoolUsageZ
PagefileUsageZPeakPagefileUsage)r1 r r r r r r r r ZGetProcessMemoryInfor r r r- Z peak_wsetZwsetZpeak_paged_poolZ
paged_poolZpeak_nonpaged_poolZ
nonpaged_poolZpagefileZ
peak_pagefiler r )r r r2 r3 r r r test_memory_info s0
z TestProcess.test_memory_infoc C sX t jtjtj| j}| jt j| tj | j}|j
|j }t j
|}| j|| d S )N)r1 r r r r r r r r r r r r ZGetExitCodeProcessr- )r r r r3 r2 r r r test_wait s
zTestProcess.test_waitc C s\ dd }t jtjtj| j}| jt j| |tj |d }t
j | jj }| j
|| d S )Nc s fddt dD S )Nc s g | ]}d |> @ r|qS )rQ r )r> i)r? r r r@ s zGTestProcess.test_cpu_affinity..from_bitmask..@ )range)r? r )r? r from_bitmask s z3TestProcess.test_cpu_affinity..from_bitmaskr )r1 r r r r r r r r ZGetProcessAffinityMaskr r Z cpu_affinityr- )r r r r2 r3 r r r test_cpu_affinity s z TestProcess.test_cpu_affinityc C s t jtjtjtj }| jt j| t j
|}t j j
}| j|j|d | j|j|d | j|j|d | j|j|d | j|j|d | j|j|d d S )NZReadOperationCountZWriteOperationCountZReadTransferCountZWriteTransferCountZOtherOperationCountZOtherTransferCount)r1 r r r r r+ r r r r ZGetProcessIoCountersr r io_countersr- Z
read_countZ write_countZ
read_bytesZ write_bytes other_countZ other_bytes)r r r2 r3 r r r test_io_counters s"
z TestProcess.test_io_countersc C s dd l }dd l}d}|jjj|dtj }| j|jjj| |j j
}|jjj ||j | |j
}tj j }|jjj| | j||d d S )Nr i rQ )ctypesZctypes.wintypesZwindllZkernel32r r+ r r r ZwintypesZDWORDZGetProcessHandleCountZbyrefvaluer r r r- )r r r r Zhndcntr2 r3 r r r test_num_handles s
z TestProcess.test_num_handlesN)r r )rf rg rh classmethodr r r r r r r r r r ri sys version_infor r r r r r r r r r r r r r r s(
$
r c @ s` e Zd ZdZedd Zedd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dS )TestProcessWMIz%Compare Process API results with WMI.c C s t j| _d S )N)r r )r r r r r s zTestProcessWMI.setUpClassc C s
t d S )N)r )r r r r r s z TestProcessWMI.tearDownClassc C s8 t j j| jdd }tj| j}| j|j |j d S )N)r= r ) r5 r6 rA r r r r- r ZCaption)r r8 r r r r test_name
s zTestProcessWMI.test_namec C s@ t j j| jdd }tj| j}| j|j j |j j d S )N)r= r )
r5 r6 rA r r r r- r r% ZExecutablePath)r r8 r r r r r s zTestProcessWMI.test_exec C sF t j j| jdd }tj| j}| jdj|j |j j
dd d S )N)r= r r! "rF ) r5 r6 rA r r r r- r r Z CommandLiner$ )r r8 r r r r r s zTestProcessWMI.test_cmdlinec C sP t j j| jdd }tj| j}|j \}}}d||f }| j|j | d S )N)r= r z%s\%s) r5 r6 rA r r r ZGetOwnerr- r )r r8 r Zdomainr r r r r r s
z TestProcessWMI.test_usernamec C sL t jd tj j| jdd }tj| j}|j j }| j
|t |j d S )Ng?)r= r )
timesleepr5 r6 rA r r r r r r- r* r )r r8 r r r r r test_memory_rss# s
z TestProcessWMI.test_memory_rssc C sj t jd tj j| jdd }tj| j}|j j }t
|j }||krf||d krf| j d||f d S )Ng?)r= r i zwmi=%s, psutil=%s)
r r r5 r6 rA r r r r r r* Z
PageFileUsager& )r r8 r r Z wmi_usager r r test_memory_vms* s
z TestProcessWMI.test_memory_vmsc C s\ t j j| jdd }tj| j}t|jjdd }t j
dt j |j }| j
|| d S )N)r= r r\ z %Y%m%d%H%M%S)r5 r6 rA r r r r Z CreationDaterU r ZstrftimeZ localtimer r- )r r8 r Z wmic_createZ
psutil_creater r r test_create_time7 s z TestProcessWMI.test_create_timeN)rf rg rh __doc__r r r r r r r r r r r r r r r s
r c @ sX e Zd ZdZedd Zedd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dS ) TestDualProcessImplementationa{
Certain APIs on Windows have 2 internal implementations, one
based on documented Windows APIs, another one based
NtQuerySystemInformation() which gets called as fallback in
case the first fails because of limited permission error.
Here we test that the two methods return the exact same value,
see:
https://github.com/giampaolo/psutil/issues/304
c C s t j| _d S )N)r r )r r r r r L s z(TestDualProcessImplementation.setUpClassc C s
t d S )N)r )r r r r r P s z+TestDualProcessImplementation.tearDownClassc
C sZ t j| jj }tjdt jtj d(}| j t j| jj | |j
sLt W d Q R X d S )Nz psutil._psplatform.cext.proc_exe) side_effect) r r r r r rd r r+ r r- rt ru )r r r r r r r W s
z'TestDualProcessImplementation.test_namec
C s t j| jj }tjdttjdd}t j| jj }| j t
|t
| xLt t
|D ]<}| j || d | j || d | j
|| || dd qZW |jstW d Q R X d S )Nz(psutil._psplatform.cext.proc_memory_infomsg)r r i )rP )r r r r r rd r r EPERMr- lenr ZassertGreaterEqualrR rt ru )r Zmem_1r Zmem_2r r r r r ^ s z.TestDualProcessImplementation.test_memory_infoc
C sX t j| jj }tjdttjdd(}| j t j| jj | |j
sJt W d Q R X d S )Nz(psutil._psplatform.cext.proc_create_timer )r ) r r r r r rd r r r r- rt ru )r Zctimer r r r r j s
z.TestDualProcessImplementation.test_create_timec C sx t j| jj }tjdttjddH}t j| jj }|j sBt
| j |j |j dd | j |j
|j
dd W d Q R X d S )Nz&psutil._psplatform.cext.proc_cpu_timesr )r g{Gz?)rP )r r r Z cpu_timesr rd r r r rt ru rR usersystem)r Z cpu_times_1r Z cpu_times_2r r r test_cpu_timesq s
z,TestDualProcessImplementation.test_cpu_timesc
C s~ t j| jj }tjdttjddN}t j| jj }x,t t
|D ] }| j || || dd qFW |j spt
W d Q R X d S )Nz(psutil._psplatform.cext.proc_io_countersr )r r0 )rP )r r r r r rd r r r r r rR rt ru )r Z
io_counters_1r Z
io_counters_2r r r r r | s z.TestDualProcessImplementation.test_io_countersc
C sX t j| jj }tjdttjdd(}| j t j| jj | |j
sJt W d Q R X d S )Nz(psutil._psplatform.cext.proc_num_handlesr )r ) r r r r r rd r r r r- rt ru )r r r r r r r s z.TestDualProcessImplementation.test_num_handlesN)
rf rg rh r r r r r r r r r r r r r r r @ s
r c @ s| e Zd ZdZedd Zedd ZddgZdd Z d
d Z
ed d
Z dd Z dd Z
dd Zdd Zdd Zdd ZdS )RemoteProcessTestCasezCertain functions require calling ReadProcessMemory.
This trivially works when called on the current process.
Check that this works on other processes, especially when they
have a different bitness.
c C sT d} xJt j dD ]<}tj|d| gtjtjd}|j \}}|tt kr|S qW d S )Nz6import sys; sys.stdout.write(str(sys.maxsize > 2**32))zC:\Python*\python.exez-c)r stdoutstderr)glob
subprocessPopenPIPEZSTDOUT communicater IS_64_BIT)codefilenamer9 outputr r r r find_other_interpreter s
z,RemoteProcessTestCase.find_other_interpreterc C s@ | j }|d krtjdtr.tj| _|| _n|| _tj| _d S )Nz0could not find interpreter with opposite bitness)r r ZSkipTestr r
executablepython64python32)r Z other_pythonr r r r s z RemoteProcessTestCase.setUpClassz-cz import sys; sys.stdin.read()c C sV t jj }tt j |d< t| jg| j |tj d| _
t| j g| j |tj d| _ d S )NTHINK_OF_A_NUMBER)envstdin)
r+ r, copyr r r r test_argsr r proc32r proc64)r r r r r setUp s
zRemoteProcessTestCase.setUpc C s | j j | jj t d S )N)r r r r )r r r r tearDown s
z RemoteProcessTestCase.tearDownc C s
t d S )N)r )r r r r r s z#RemoteProcessTestCase.tearDownClassc C s@ t j| jj}| jt|j d | j|j dd | j d S )Nr] rQ )r r r r r- r r r )r r r r r test_cmdline_32 s z%RemoteProcessTestCase.test_cmdline_32c C s@ t j| jj}| jt|j d | j|j dd | j d S )Nr] rQ )r r r r r- r r r )r r r r r test_cmdline_64 s z%RemoteProcessTestCase.test_cmdline_64c C s& t j| jj}| j|j tj d S )N)r r r r r- cwdr+ getcwd)r r r r r test_cwd_32 s z!RemoteProcessTestCase.test_cwd_32c C s& t j| jj}| j|j tj d S )N)r r r r r- r r+ r )r r r r r test_cwd_64 s z!RemoteProcessTestCase.test_cwd_64c C s> t j| jj}|j }| jd| | j|d ttj d S )Nr )
r r r r r, assertIn assertEqualsr r+ r )r r er r r test_environ_32 s z%RemoteProcessTestCase.test_environ_32c C s> t j| jj}|j }| jd| | j|d ttj d S )Nr )
r r r r r, r r
r r+ r )r r r r r r test_environ_64 s z%RemoteProcessTestCase.test_environ_64N)rf rg rh r staticmethodr r r r r r r r r r
r r r r r r r r s
r c @ s e Zd Zdd Zdd ZdS ) TestServicesc C sn t dddddddg}t dd d
g}t ddd d d
ddg}x,tj D ] }|j }| j|d t | j|d j d | j|d t | j|d t | j|d | |d d k rtj |d | j|d t | j|d t | j|d t | j|d | | j|d | | j|d t |j
}|d k rLtj |}| j |j tj
|j }| j|| qFW d S )NZrunningZpausedstartpausecontinuestopZstoppedZ automaticZmanualZdisabledZ
start_pendingZ
pause_pendingZcontinue_pendingZ stop_pendingr rF display_namer statusr ZbinpathZ
start_type description)rB r win_service_iterr ZassertIsInstancer ZassertNotEqualr r r r rZ Z
is_runningwin_service_getr r- )r Zvalid_statusesZvalid_start_typesZservdatar r sr r r test_win_service_iter sR
z"TestServices.test_win_service_iterc ' C sp t tj j }| jtj}tj|d W d Q R X | j|jj|d tj|}t tj
j j d}t
jd|d | jtj|j W d Q R X t
jd|d | jtj|j W d Q R X t tj
j jd}t
jd|d | jtj|j W d Q R X t
jd|d | jtj|j W d Q R X | j|j t| | j|j t| | j|j t| | j|j t| d S )Nz???rF z/psutil._psplatform.cext.winservice_query_status)r z/psutil._psplatform.cext.winservice_query_config)nextr r r r r r r- Z exceptionZ WindowsError _psplatformrW Z ERROR_SERVICE_DOES_NOT_EXISTr rd r r ZERROR_ACCESS_DENIEDr r r r rN )r r cmZserviceexcr r r test_win_service_get! s2
z!TestServices.test_win_service_getN)rf rg rh r r# r r r r r s 0r __main__l )2r r^ r r r+ r r r r r r warningsr r Zpsutil._compatr Z psutil.testsr r r r r r r
r r catch_warnings simplefilterr1 r r r5 ImportErrorr r rW maxsizer r ri ZTestCaser rj r r r r r rf __file__r r r r sl
<
m
A
N
^
U
PK ! + __pycache__/test_linux.cpython-36.opt-1.pycnu [ 3
JZ3 @ s d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lm Z dd lm Z dd
lm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddlm%Z% ddlm&Z& ddlm'Z' ddlm(Z( ddlm)Z) ddlm*Z* ddlm+Z+ ej,j-ej,j.e/Z0dZ1d Z2d Z3erd Z4d d Z5d!d" Z6d#d$ Z7d%d& Z8d'd( Z9d)d* Z:e*j;e d+G d,d- d-e*j<Z=e*j;e d+G d.d/ d/e*j<Z>e*j;e d+G d0d1 d1e*j<Z?e*j;e d+G d2d3 d3e*j<Z@e*j;e d+G d4d5 d5e*j<ZAe*j;e d+G d6d7 d7e*j<ZBe*j;e d+G d8d9 d9e*j<ZCe*j;e d+e*j;e d:G d;d< d d>e*j<ZEe*j;e d+G d?d@ d@e*j<ZFe*j;e d+G dAdB dBe*j<ZGe*j;e d+G dCdD dDe*j<ZHe*j;e d+G dEdF dFe*j<ZIeJdGkre#e/ dS )HzLinux specific tests. )divisionN)LINUX)PY3)u)
call_until) HAS_BATTERY) HAS_CPU_FREQ)
HAS_RLIMIT)MEMORY_TOLERANCE)mock)PYPY)pyrun)
reap_children)
reload_module)retry_before_failing)run_test_module_by_name) safe_rmpath)sh)skip_on_not_implemented)TESTFN)
ThreadTask)TRAVIS)unittest)whichi i i' i c C sp dd l }| d d } tr"t| d} tjtjtj}tj|* tj|j |j
t t j
d| dd S Q R X d S )Nr ascii256s )fcntlr bytessocketAF_INET
SOCK_DGRAM
contextlibclosingZ inet_ntoaioctlfileno SIOCGIFADDRstructpack)ifnamer s r- "/usr/lib64/python3.6/test_linux.pyget_ipv4_address@ s
r/ c
s dd l }| d d } tr"t| d} tjtjtj}tj|` |j|j t
t j d| }trfdd ndd l
}|j dj fdd |d
d D d d
S Q R X d S )Nr r r r c S s | S )Nr- )xr- r- r. ordW s z get_mac_address..ord c s g | ]}d | qS )z%02x:r- ).0char)r1 r- r.
\ s z#get_mac_address.. r )r r r r! r" r# r$ r% r& r'
SIOCGIFHWADDRr) r* __builtin__r1 join)r+ r r, infor: r- )r1 r. get_mac_addressM s
r= c C st t d} | jd}xJ|D ]B}|jdr|j \}}}}tjdd}|t|t|t|S qW tddj| dS )zQParse 'free' cmd and return swap memory's s total, used and free
values.
zfree -b
ZSwapfreeztotal used freez&can't find 'Swap' in 'free' output:
%sN)r split
startswith collections
namedtupleint
ValueErrorr; )outlinesline_totalusedr? ntr- r- r. free_swap_ s
rM c C s~ t d} | jd}xT|D ]L}|jdrdd |j dd D \}}}}tjdd }|||||| S qW td
dj| d S ) zSParse 'free' cmd and return physical memory's total, used
and free values.
zfree -br> ZMemc S s g | ] }t |qS r- )rD )r3 r0 r- r- r. r5 { s z free_physmem..r7 r? z total used free shared outputz%can't find 'Mem' in 'free' output:
%sN)r r@ rA rB rC rE r; )rF rG rH rJ rK r? sharedrL r- r- r. free_physmemn s
"rP c C sN t d}x4|jdD ]&}|j }| |krt|jdd S qW td| d S )Nz vmstat -sr> r z can't find %r in 'vmstat' output)r r@ striprD rE )statrF rH r- r- r. vmstat s rT c C s( t dj } ttt| j d jdS )Nzfree -Vr7 .r8 )r rR tuplemaprD r@ )rF r- r- r. get_free_version_info s rX z
LINUX onlyc @ s e Zd Zdd Zejeo e d k de dd Z eje
de d d
Z e d d Z eje
de d
d Z
eje
de dd Ze dd Ze dd Zdd Zdd Zdd Zdd Zd d Zd S )!TestSystemVirtualMemoryc C s& t dd }tj j}| j|| d S )Nz total memoryi )rT psutilvirtual_memoryrJ assertAlmostEqual)self vmstat_value psutil_valuer- r- r.
test_total s
z"TestSystemVirtualMemory.test_total zold free versionc C s8 t }|j}tj j}| j||td|||jf d d S )Nz %s %s
%s)deltamsg)rP rK rZ r[ r\ r
output)r] r?
free_valuer_ r- r- r. test_used s
z!TestSystemVirtualMemory.test_usedzunreliable on TRAVISc C s* t dd }tj j}| j||td d S )Nz free memoryi )rc )rT rZ r[ r? r\ r
)r] r^ r_ r- r- r. test_free s
z!TestSystemVirtualMemory.test_freec C s* t dd }tj j}| j||td d S )Nz
buffer memoryi )rc )rT rZ r[ buffersr\ r
)r] r^ r_ r- r- r. test_buffers s
z$TestSystemVirtualMemory.test_buffersc C s* t dd }tj j}| j||td d S )Nz
active memoryi )rc )rT rZ r[ activer\ r
)r] r^ r_ r- r- r. test_active s
z#TestSystemVirtualMemory.test_activec C s* t dd }tj j}| j||td d S )Nzinactive memoryi )rc )rT rZ r[ inactiver\ r
)r] r^ r_ r- r- r.
test_inactive s
z%TestSystemVirtualMemory.test_inactivec C sJ t }|j}|dkr tjdtj j}| j||td|||jf d d S )Nr z%free does not support 'shared' columnz %s %s
%s)rc rd ) rP rO r SkipTestrZ r[ r\ r
re )r] r? rf r_ r- r- r. test_shared s
z#TestSystemVirtualMemory.test_sharedc C sh t d}|jd}d|d kr*tjdn:t|d j d }tj j}| j||t d|||f d d S )
Nzfree -br> availabler z(free does not support 'available' columnr7 z %s %s
%s)rc rd r8 )
r r@ r ro rD rZ r[ rq r\ r
)r] rF rG rf r_ r- r- r. test_available s
z&TestSystemVirtualMemory.test_availablec sT fdd}t trdnd}tj|d|d }tjdd}tjd tj }| j t
|d |d
}| j d t |j
| j d t |j
| j d
t |j
| j dt |j
| j dt |j
| j dt |j
| j dt |j
| j |jd
| j |jd
| j |jd
| j |jd
| j |jd
| j |jd
W d Q R X W d Q R X d S )Nc s0 | dkr t jtjdj S | f||S d S )Nz
/proc/meminfoa Active(anon): 6145416 kB
Active(file): 2950064 kB
Inactive(anon): 574764 kB
Inactive(file): 1567648 kB
MemAvailable: -1 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
SReclaimable: 346648 kB
)ioBytesIOtextwrapdedentencode)nameargskwargs) orig_openr- r. open_mock s zBTestSystemVirtualMemory.test_warnings_on_misses..open_mockz
builtins.openz__builtin__.openT)create side_effect)recordalwaysr7 r z#memory stats couldn't be determinedcachedrO rk rm ri rq )openr r patchwarningscatch_warnings simplefilterrZ r[ assertEquallenassertInstrmessager rk rm rO ri rq )r] r| patch_pointmwsretwr- )r{ r. test_warnings_on_misses s.
z/TestSystemVirtualMemory.test_warnings_on_missesc
C s ddl m} ddl m} i }|d4}x,|D ]$}|j }t|d d ||d < q,W W d Q R X ||}d|kr|d }t|| | d } | j| d d S )
Nr )calculate_avail_vmem) open_binaryz
/proc/meminfor7 i s
MemAvailable:d
)psutil._pslinuxr r r@ rD absZ
assertLess)
r] r r ZmemsfrH fieldsabZ diff_percentr- r- r. test_avail_old_percent s
&z.TestSystemVirtualMemory.test_avail_old_percentc s fdd}t trdnd}tj|d|dN}tjdd}tj }W d Q R X | j|j d |d
}| j
d t |j W d Q R X d S )
Nc s0 | dkr t jtjdj S | f||S d S )Nz
/proc/meminfoa Active: 9444728 kB
Active(anon): 6145416 kB
Active(file): 2950064 kB
Buffers: 287952 kB
Cached: 4818144 kB
Inactive(file): 1578132 kB
Inactive(anon): 574764 kB
Inactive(file): 1567648 kB
MemAvailable: 6574984 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
Shmem: 577588 kB
SReclaimable: 346648 kB
)rs rt ru rv rw )rx ry rz )r{ r- r. r| 0 s zKTestSystemVirtualMemory.test_avail_old_comes_from_kernel..open_mockz
builtins.openz__builtin__.openT)r} r~ )r iSd i r z,inactive memory stats couldn't be determinedl " )
r r r r r r rZ r[ r rq r r r )r] r| r r r r r r- )r{ r. test_avail_old_comes_from_kernel- s z8TestSystemVirtualMemory.test_avail_old_comes_from_kernelc s fdd}t trdnd}tj|d|dN}tjdd}tj }W d Q R X | j|j d |d }| j
d t |j W d Q R X d S )Nc s0 | dkr t jtjdj S | f||S d S )Nz
/proc/meminfoa Active: 9444728 kB
Active(anon): 6145416 kB
Buffers: 287952 kB
Cached: 4818144 kB
Inactive(file): 1578132 kB
Inactive(anon): 574764 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
Shmem: 577588 kB
)rs rt ru rv rw )rx ry rz )r{ r- r. r| S s
zHTestSystemVirtualMemory.test_avail_old_missing_fields..open_mockz
builtins.openz__builtin__.openT)r} r~ )r id i iI r z,inactive memory stats couldn't be determinedi }l 'L l `LG )
r r r r r r rZ r[ r rq r r r )r] r| r r r r r r- )r{ r. test_avail_old_missing_fieldsO s z5TestSystemVirtualMemory.test_avail_old_missing_fieldsc s fdd}t trdnd}tj|d|dN}tjdd}tj }W d Q R X | j|j d |d }| j
d t |j W d Q R X d S )Nc sF | dkr t jtjdj S | dkr2ttjdn | f||S d S )Nz
/proc/meminfoaT Active: 9444728 kB
Active(anon): 6145416 kB
Active(file): 2950064 kB
Buffers: 287952 kB
Cached: 4818144 kB
Inactive(file): 1578132 kB
Inactive(anon): 574764 kB
Inactive(file): 1567648 kB
MemFree: 2057400 kB
MemTotal: 16325648 kB
Shmem: 577588 kB
SReclaimable: 346648 kB
z/proc/zoneinfozno such file or directory)rs rt ru rv rw IOErrorerrnoENOENT)rx ry rz )r{ r- r. r| q s
zJTestSystemVirtualMemory.test_avail_old_missing_zoneinfo..open_mockz
builtins.openz__builtin__.openT)r} r~ )r id i iI r z,inactive memory stats couldn't be determinedi }l 'L l `LG )
r r r r r r rZ r[ r rq r r r )r] r| r r r r r r- )r{ r. test_avail_old_missing_zoneinfon s z7TestSystemVirtualMemory.test_avail_old_missing_zoneinfoN)ra ra rb )__name__
__module__ __qualname__r` r skipIfr rX r rg r rh rj rl rn rp rr r r r r r r- r- r- r. rY s$
," rY c @ s\ e Zd Zedd Zdd Ze dd Ze dd Zd d
Z d d Z
d
d Z dd Z dS )TestSystemSwapMemoryc C s, t d} | j }W dQ R X d|ko*d|kS )z3Return True if /proc/meminfo provides swap metrics.z
/proc/meminfoNz
SwapTotal:z SwapFree:)r read)r datar- r- r. meminfo_has_swap_info s
z*TestSystemSwapMemory.meminfo_has_swap_infoc C s" t j}tj j}| j||tdS )N)rc )rM rJ rZ swap_memoryr\ r
)r] rf r_ r- r- r. r` s
z TestSystemSwapMemory.test_totalc C s" t j}tj j}| j||tdS )N)rc )rM rK rZ r r\ r
)r] rf r_ r- r- r. rg s
z TestSystemSwapMemory.test_usedc C s" t j}tj j}| j||tdS )N)rc )rM r? rZ r r\ r
)r] rf r_ r- r- r. rh s
z TestSystemSwapMemory.test_freec C s t jdddv}tjdd^}tjd tj }| jt|d |d }| j dt
|j | j|j d | j|j
d W d Q R X W d Q R X d S ) Nzpsutil._pslinux.openT)r} )r r r7 r z9'sin' and 'sout' swap memory stats couldn't be determined)r r r r r rZ r r r r r r sinsout)r] r r r r r- r- r. test_missing_sin_sout s
z*TestSystemSwapMemory.test_missing_sin_soutc s fdd}t trdnd}tj|d|dv}tjdd^}tjd tj }| j t
|d |d
}| j d t |j
| j |jd
| j |jd
W d Q R X W d Q R X d S ) Nc s* | dkrt tjdn | f||S d S )Nz /proc/vmstatzno such file or directory)r r r )rx ry rz )r{ r- r. r| s z=TestSystemSwapMemory.test_no_vmstat_mocked..open_mockz
builtins.openz__builtin__.openT)r} r~ )r r r7 r zK'sin' and 'sout' swap memory stats couldn't be determined and were set to 0)r r r r r r r rZ r r r r r r r r )r] r| r r r r r r- )r{ r. test_no_vmstat_mocked s
z*TestSystemSwapMemory.test_no_vmstat_mockedc C s | j stjdS tjd}tj }W d Q R X dd lj}|j \}}}}}}}||9 }||9 }| j
|j | | j
|j | d S )Nz!/proc/meminfo has no swap metricsz"psutil._pslinux.cext.linux_sysinfor )
r r skipr r rZ r Zpsutil._psutil_linuxZ
_psutil_linuxZ
linux_sysinfor rJ r? )r] r swapZcextrI rJ r? Zunit_multiplierr- r- r. test_meminfo_against_sysinfo s
z1TestSystemSwapMemory.test_meminfo_against_sysinfoc sD fdd}t trdnd}tj|d|d}tj W d Q R X d S )Nc s& | dkrt jdS | f||S d S )Nz
/proc/meminfo )rs rt )rx ry rz )r{ r- r. r| s
zKTestSystemSwapMemory.test_emulate_meminfo_has_no_metrics..open_mockz
builtins.openz__builtin__.openT)r} r~ )r r r r rZ r )r] r| r r r- )r{ r. #test_emulate_meminfo_has_no_metrics s z8TestSystemSwapMemory.test_emulate_meminfo_has_no_metricsN)
r r r staticmethodr r` r rg rh r r r r r- r- r- r. r s r c @ s& e Zd Zejeddd Zejejj d ddd Z
ejejj d d d
d Z eje d d
dd Z
eje d ddd Zdd Zdd Zeje ddd Zejedeje dd d Zeje dd d Zeje dd d! Zejedeje dd"d# Zd$S )%
TestSystemCPUzunknown failure on travisc C s t j j}tjdtj d d }ttt |j
d}|d krL| j d| n | j d| |d
krn| j d | n | j d | |dkr| j d | n | j d | d S )Nz
\d+\.\d+\.\d+ r rU Zstealr Zguestra Z
guest_nice)r r r )r r r )ra r r )
rZ cpu_times_fieldsrefindallosunamerV rW rD r@ r assertNotIn)r] r Z
kernel_verZkernel_ver_infor- r- r. test_cpu_times s
z TestSystemCPU.test_cpu_timesz /sys/devices/system/cpu/onlinez-/sys/devices/system/cpu/online does not existc
C sV t d}|j j }W d Q R X dt|krRt|jdd d }| jtj | d S )Nz /sys/devices/system/cpu/online-r7 ) r r rR r rD r@ r rZ cpu_count)r] r valuer- r- r. *test_cpu_count_logical_w_sysdev_cpu_online s
z8TestSystemCPU.test_cpu_count_logical_w_sysdev_cpu_onlinez/sys/devices/system/cpuz&/sys/devices/system/cpu does not existc C s0 t jd}tdd |D }| jtj | d S )Nz/sys/devices/system/cpuc S s g | ]}t jd |dk r|qS )zcpu\d+$N)r search)r3 r0 r- r- r. r5 % s zITestSystemCPU.test_cpu_count_logical_w_sysdev_cpu_num..)r listdirr r rZ r )r] Zlscountr- r- r. 'test_cpu_count_logical_w_sysdev_cpu_num! s
z5TestSystemCPU.test_cpu_count_logical_w_sysdev_cpu_numZnprocznproc utility not availablec C s$ t td}| jtjdd| d S )Nz nproc --allT)logical)rD r r rZ r )r] numr- r- r. test_cpu_count_logical_w_nproc( s z,TestSystemCPU.test_cpu_count_logical_w_nprocZlscpuzlscpu utility not availablec C s8 t d}tdd |jdD }| jtjdd| d S )Nzlscpu -pc S s g | ]}|j d s|qS )#)rA )r3 r0 r- r- r. r5 0 s z@TestSystemCPU.test_cpu_count_logical_w_lscpu..r> T)r )r r r@ r rZ r )r] rF r r- r- r. test_cpu_count_logical_w_lscpu- s z,TestSystemCPU.test_cpu_count_logical_w_lscpuc & s2 dd l }|jj }tjdtd}| j|jj | tjddd:}| j|jj | j|jd | j|j d d d W d Q R X t
d d
}|j }W d Q R X t j
|}tjd|dd }| j|jj | W d Q R X fd d
}t
trdnd}tj||dd | j|jj | W d Q R X W d Q R X d S )Nr zpsutil._pslinux.os.sysconf)r~ zpsutil._pslinux.openT)r} r z
/proc/statz
/proc/cpuinforb) return_valuer} c s( | j drtjdS | f||S d S )Nz
/proc/cpuinfor )rA rs rt )rx ry rz )r{ r- r. r| P s
z>TestSystemCPU.test_cpu_count_logical_mocked..open_mockz
builtins.openz__builtin__.open)r~ r} )r _pslinuxZcpu_count_logicalr r rE r assertIsNoneZ
call_count call_argsr r rs rt r ) r] rZ originalr r Z cpuinfo_data fake_filer| r r- )r{ r. test_cpu_count_logical_mocked3 s(
z+TestSystemCPU.test_cpu_count_logical_mockedc C s. t jddd}| jtjj W d Q R X d S )Nzpsutil._pslinux.openT)r} )r r r rZ r Zcpu_count_physical)r] r r- r- r. test_cpu_count_physical_mocked[ s z,TestSystemCPU.test_cpu_count_physical_mockedz
not supportedc C s, t jdg d | jtj W d Q R X d S )Nzpsutil._pslinux.glob.glob)r )r r r rZ cpu_freq)r] r- r- r. test_cpu_freq_no_resultb s z%TestSystemCPU.test_cpu_freq_no_resultzfails on Travisc
sH fdd}g t j tjd|dd | jt d W d Q R X d S )Nc s. | j dr jd g S jd | S d S )Nz&/sys/devices/system/cpu/cpufreq/policy)rA append)pattern)flags orig_globr- r. glob_mockk s
z>TestSystemCPU.test_cpu_freq_use_second_file..glob_mockzpsutil._pslinux.glob.globT)r~ r} r )globr r r r )r] r r- )r r r. test_cpu_freq_use_second_fileg s
z+TestSystemCPU.test_cpu_freq_use_second_filec s fdd}t trdnd}tj||dT tjddgd8 tj }| j|jd | j|jd
| j|j d W d Q R X W d Q R X d S ) Nc sP | j drtjdS | j dr(tjdS | j dr.open_mockz
builtins.openz__builtin__.open)r~ z glob.globz'/sys/devices/system/cpu/cpufreq/policy0)r g @@g @g @)
r r r r rZ r r currentminmax)r] r| r freqr- )r{ r. test_cpu_freq_emulate_dataz s
z(TestSystemCPU.test_cpu_freq_emulate_datac s fdd}t trdnd}dddg}tj||dR tjd |d
8 tj }| j|jd | j|jd | j|j d
W d Q R X W d Q R X d S )Nc sP | j drtjdS | j dr(tjdS | j dr.open_mockz
builtins.openz__builtin__.openz'/sys/devices/system/cpu/cpufreq/policy0z'/sys/devices/system/cpu/cpufreq/policy1z'/sys/devices/system/cpu/cpufreq/policy2)r~ z glob.glob)r g Y@g i@g r@)
r r r r rZ r r r r r )r] r| r policiesr r- )r{ r. test_cpu_freq_emulate_multi_cpu s
z-TestSystemCPU.test_cpu_freq_emulate_multi_cpuc s fdd}t trdnd}dddg}tj||d6 tjd |d
tj }| j|jd W d Q R X W d Q R X fd d}t trdnd}tj||d. tjd |d
| jt tj W d Q R X W d Q R X d S )
Nc s@ | j drttjdn$| j dr,tjdS | f||S d S )Nz/scaling_cur_freqr2 z/cpuinfo_cur_freqs 200000)r r r r rs rt )rx ry rz )r{ r- r. r| s
zGTestSystemCPU.test_cpu_freq_no_scaling_cur_freq_file..open_mockz
builtins.openz__builtin__.openz'/sys/devices/system/cpu/cpufreq/policy0z'/sys/devices/system/cpu/cpufreq/policy1z'/sys/devices/system/cpu/cpufreq/policy2)r~ z glob.glob)r c sD | j drttjdn(| j dr0ttjdn | f||S d S )Nz/scaling_cur_freqr2 z/cpuinfo_cur_freq)r r r r )rx ry rz )r{ r- r. r| s
)
r r r r rZ r r r assertRaisesNotImplementedError)r] r| r r r r- )r{ r. &test_cpu_freq_no_scaling_cur_freq_file s " z4TestSystemCPU.test_cpu_freq_no_scaling_cur_freq_fileN)r r r r r r r r pathexistsr r r r r r r r r r r r r r- r- r- r. r s (
r c @ s4 e Zd Zejeddd Zejeddd ZdS )TestSystemCPUStatszfails on Travisc C s& t d}tj j}| j||dd d S )Nzcontext switchesi )rc )rT rZ cpu_statsZ ctx_switchesr\ )r] r^ r_ r- r- r. test_ctx_switches s
z$TestSystemCPUStats.test_ctx_switchesc C s& t d}tj j}| j||dd d S )N
interruptsi )rc )rT rZ r r r\ )r] r^ r_ r- r- r. test_interrupts s
z"TestSystemCPUStats.test_interruptsN)r r r r r r r r r- r- r- r. r s r c @ s| e Zd Zdd Zdd Ze dd Zeje d deje
d d
d Z e j
d ed
e j
ddddd Zdd ZdS )TestSystemNetworkc C sj xdt j j D ]T\}}xJ|D ]B}|jt jkr@| j|jt| q |jtj kr | j|jt
| q W qW d S )N) rZ net_if_addrsitemsZfamilyZAF_LINKr Zaddressr= r! r" r/ )r] rx ZaddrsZaddrr- r- r. test_net_if_addrs_ips s
z'TestSystemNetwork.test_net_if_addrs_ipsc C sb x\t j j D ]L\}}ytd| }W n tk
r: Y qX | j|jttj d|d qW d S )Nz ifconfig %sz(?i)MTU[: ](\d+)r )
rZ net_if_statsr r RuntimeErrorr ZmturD r r )r] rx statsrF r- r- r. test_net_if_stats s z#TestSystemNetwork.test_net_if_statsc s fdd}t jddd}x|j D ]\ }y | }W n tk
rN w$Y nX | j|j|d dd | j|j|d
dd | j|j|d dd | j|j|d dd | j|j |d
dd | j|j
|d dd | j|j |d dd | j|j |d dd q$W d S )Nc s i }t d }ttjd|d |d< ttjd|d |d< ttjd|d |d< ttjd|d |d
< ttjd |d |d < ttjd |d |d
< ttjd|d |d< ttjd|d |d< |S )Nz ifconfig %szRX packets[: ](\d+)r packets_recvzTX packets[: ](\d+) packets_sentzerrors[: ](\d+)errinr7 erroutzdropped[: ](\d+)dropindropoutz#RX (?:packets \d+ +)?bytes[: ](\d+)
bytes_recvz#TX (?:packets \d+ +)?bytes[: ](\d+)
bytes_sent)r rD r r )Znicr rF )rx r- r. ifconfig s z8TestSystemNetwork.test_net_io_counters..ifconfigTF)Zpernicnowrapr i rN )rc r r r r r r r r i i )
rZ net_io_countersr r r\ r r r r r r r r )r] r Znior Z ifconfig_retr- )rx r. test_net_io_counters s. z&TestSystemNetwork.test_net_io_countersZipz'ip' utility not availablezskipped on Travisc C s t dj }dd tj j D }d}xL|jdD ]>}|j }tjd|r2|d7 }|jdd j }| j|| q2W | j t
||d t j ||f d
d S ) Nzip addrc S s g | ]}d |kr|qS ):r- )r3 r0 r- r- r. r5 2 s z7TestSystemNetwork.test_net_if_names..r r> z^\d+:r7 r z %s
---
%s)rd )
r rR rZ r keysr@ r r r r r pprintZpformat)r] rF ZnicsfoundrH rx r- r- r. test_net_if_names. s z#TestSystemNetwork.test_net_if_namesz psutil._pslinux.socket.inet_ntop)r~ z psutil._pslinux.supports_ipv6F)r c C sR y*t j t jt j}| j|j |jd W n t jk
r@ Y nX tjdd d S )N::1r Zinet6)kind)r
r ) r! ZAF_INET6Z SOCK_STREAM
addCleanupcloseZbinderrorrZ net_connections)r] Z
supports_ipv6Z inet_ntopr, r- r- r. %test_net_connections_ipv6_unsupported= s z7TestSystemNetwork.test_net_connections_ipv6_unsupportedc
sF fdd}t trdnd}tj||d}tjdd W d Q R X d S )Nc s, | dkrt jtjdS | f||S d S )Nz/proc/net/unixaB 0: 00000003 000 000 0001 03 462170 @/tmp/dbus-Qw2hMPIU3n
0: 00000003 000 000 0001 03 35010 @/tmp/dbus-tB2X8h69BQ
0: 00000003 000 000 0001 03 34424 @/tmp/dbus-cHy80Y8O
000000000000000000000000000000000000000000000000000000
)rs StringIOru rv )rx ry rz )r{ r- r. r| J s z@TestSystemNetwork.test_net_connections_mocked..open_mockz
builtins.openz__builtin__.open)r~ Zunix)r )r r r r rZ r )r] r| r r r- )r{ r. test_net_connections_mockedI s z-TestSystemNetwork.test_net_connections_mockedN)r r r r r r r r r r r r r r rE r r r- r- r- r. r s * r c @ sN e Zd Zejeed de dd Zdd Z dd Z
d d
Z d d Z d
S )TestSystemDisksstatvfszos.statvfs() not availablec C s dd }xt jddD ]|}t j|j}||j\}}}}| j|j| t|j| d krl| jd|j|f t|j | d kr| jd|j |f qW d S ) Nc S sz t d| j }|jd}|jd |jd}|j d d \}}}}|dkrRd}t|t|t| }}}||||fS )Nzdf -P -B 1 "%s"r> r Znoner2 )r rR r@ poprD )r rF rG rH devrJ rK r? r- r- r. dfi s
z:TestSystemDisks.test_disk_partitions_and_usage..dfF)allr i zpsutil=%s, df=%si ( i i ( i )
rZ disk_partitionsZ
disk_usageZ
mountpointr rJ r r? failrK )r] r partZusager rJ rK r? r- r- r. test_disk_partitions_and_usaged s z.TestSystemDisks.test_disk_partitions_and_usagec C s t dd}|j }W d Q R X d|krPxtj D ]}|jdkr0P q0W | jd n`tjtd}t j
d|dd<}t j
d dgd
}tj }| j |d jd W d Q R X W d Q R X d S )Nz/proc/filesystemsrzfsz couldn't find any ZFS partitionz
nodev zfs
zpsutil._pslinux.openT)r r} z$psutil._pslinux.cext.disk_partitions /dev/sdb3/rw)r r )r# r$ r" r% ) r r rZ r Zfstyper rs r r r r r )r] r r r r m1m2r r- r- r. test_disk_partitions_mocked~ s
z+TestSystemDisks.test_disk_partitions_mockedc s fdd}t trdnd}tj||d}tjdd}| j|jd | j|jd | j|j d
t
| j|j d | j|j d | j|j
d
| j|jdt
| j|jd | j|jd W d Q R X d S )Nc sB | dkrt jtjdS | dkr.t jtdS | f||S d S )Nz/proc/partitionszu major minor #blocks name
8 0 488386584 hda
z/proc/diskstatsz+ 3 0 1 hda 2 3 4 5 6 7 8 9 10 11 12)rs r ru rv r )rx ry rz )r{ r- r. r| s
zJTestSystemDisks.test_disk_io_counters_kernel_2_4_mocked..open_mockz
builtins.openz__builtin__.open)r~ F)r r7 r ra r rN r r )r r r r rZ disk_io_countersr
read_countread_merged_count
read_bytes SECTOR_SIZE read_time write_countwrite_merged_count write_bytes
write_time busy_time)r] r| r r r r- )r{ r. 'test_disk_io_counters_kernel_2_4_mocked s
z7TestSystemDisks.test_disk_io_counters_kernel_2_4_mockedc s fdd}t trdnd}tj||d}tjdd}| j|jd | j|jd | j|j d
t
| j|j d | j|j d | j|j
d
| j|jdt
| j|jd | j|jd W d Q R X d S )Nc sB | dkrt jtjdS | dkr.t jtdS | f||S d S )Nz/proc/partitionszu major minor #blocks name
8 0 488386584 hda
z/proc/diskstatsz' 3 0 hda 1 2 3 4 5 6 7 8 9 10 11)rs r ru rv r )rx ry rz )r{ r- r. r| s
zOTestSystemDisks.test_disk_io_counters_kernel_2_6_full_mocked..open_mockz
builtins.openz__builtin__.open)r~ F)r r7 r ra r rN r r) r* r )r r r r rZ r+ r r, r- r. r/ r0 r1 r2 r3 r4 r5 )r] r| r r r r- )r{ r. ,test_disk_io_counters_kernel_2_6_full_mocked s
z.open_mockz
builtins.openz__builtin__.open)r~ F)r r7 r ra r r )r r r r rZ r+ r r, r. r/ r1 r3 r- r0 r2 r4 r5 )r] r| r r r r- )r{ r. /test_disk_io_counters_kernel_2_6_limited_mocked s
z?TestSystemDisks.test_disk_io_counters_kernel_2_6_limited_mockedN)
r r r r r hasattrr r r r( r6 r7 r8 r- r- r- r. r a s r c @ sV e Zd Zdd Zejddd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dS )TestMiscc C s( t d}tj }| jt|t| d S )Nz boot time)rT rZ boot_timer rD )r] r^ r_ r- r- r. test_boot_time s zTestMisc.test_boot_timezpsutil.traceback.print_excc " s t j }ttjj|dd$}|jd |jd |jd W d Q R X zt fdd}trbdnd }tj ||d
n t
t | j t
t j | j t
t jd d | j t
t j | j t
t jd d | j t
t j | j t
t jd d |t _| jt j d
| jtt j d
t jd d }| jt|d
t jd d }| jttt|d
ttjj|dd$}|jd |jd |jd W d Q R X | jt j d
| jtt jd d d
| jtt j d
| jtttt jd d d
W d Q R X W d tj| t
t X | jt jd d S )NrS r zcpu 0 0 0 0 0 0 0 0 0 0
zcpu0 0 0 0 0 0 0 0 0 0 0
zcpu1 0 0 0 0 0 0 0 0 0 0
c s& | j drttjd | f||S )Nz/proczrejecting access for test)rA r r r )rx ry rz )r{ r- r. r| s
z4TestMisc.test_no_procfs_on_import..open_mockz
builtins.openz__builtin__.open)r~ T)percpur zcpu 1 0 0 0 0 0 0 0 0 0
zcpu0 1 0 0 0 0 0 0 0 0 0
zcpu1 1 0 0 0 0 0 0 0 0 0
z/proc)tempfilemkdtempr r r r; writer r r r rZ r r r Z cpu_percentZcpu_times_percent PROCFS_PATHr sumrW ZassertNotEqualshutilZrmtree)r] tbZ my_procfsr r| r Zper_cpu_percentZper_cpu_times_percentr- )r{ r. test_no_procfs_on_import sL
(
z!TestMisc.test_no_procfs_on_importc
C s. t jddd}| jttjj W d Q R X d S )Nzpsutil._pslinux.openT)r} )r r r r rZ r r; )r] r r- r- r. test_boot_time_mockedD s
z TestMisc.test_boot_time_mockedc C s t jdd
gd }| jtj d jd
W d Q R X t jddgd }| jtj d jd
W d Q R X t jddgd }| jtj d jd W d Q R X d S )Nzpsutil._pslinux.cext.users giampaolopts/2:0 hATr )r r Z localhost:0.0foo)rG rH rI rJ Tr )rG rH rK rJ Tr )rG rH rL rJ Tr )r r r rZ Zusershost)r] r r- r- r. test_users_mockedK s
zTestMisc.test_users_mockedc C s t j }z|t_| jttj | jttj | jttjdd | jttj | jttj | jttj
| jttj | jttj | jttj
| jtjtj W d dt_tj| X d S )NT)r= z/proc)r> r? rZ rA r r r[ r r; r r r r+ r Z
NoSuchProcessProcessr rmdir)r] Ztdirr- r- r. test_procfs_path_ s zTestMisc.test_procfs_pathc sH fdd}g t tr dnd}tj||d tj W d Q R X d S )Nc sJ t rt| tr| j } d| kr6 jd ttjdn| f||S d S )NZhw_sector_sizer2 )r
isinstancer decoder r r r )rx ry rz )flagr{ r- r. r| u s
z1TestMisc.test_sector_size_mock..open_mockz
builtins.openz__builtin__.open)r~ )r r r r rZ r+ )r] r| r r- )rT r{ r. test_sector_size_mockr s z TestMisc.test_sector_size_mockc
C sZ t }|j z.open_mockz
builtins.openz__builtin__.open)r~ )r r r r )r] r| r r- )r{ r. test_pid_exists_no_proc_status s
z'TestMisc.test_pid_exists_no_proc_statusN)
r r r r< r r rE rF rN rQ rU r] r_ r- r- r- r. r: s >r: z
no batteryc @ s e Zd Zejed ddd Zejed ddd Zdd Zd d
Z d d Z
d
d Z dd Z dd Z
dd Zdd Zdd Zdd ZdS ) TestSensorsBatteryZacpizacpi utility not availablec C sD t d}t|jdd j jdd}tj j}| j||dd d S )Nzacpi -b,r7 %r2 )rc ) r rD r@ rR replacerZ sensors_batterypercentr\ )r] rF Z
acpi_valuer_ r- r- r. test_percent s
z TestSensorsBattery.test_percentc C sT t d}d|j kr tjdS d|kr,d}nd|jdd k}| jtj j| d S ) Nzacpi -bunknownzacpi output not reliablezdischarging at zero rateTZChargingr> r ) r lowerr r r@ r rZ rd
power_plugged)r] rF Zpluggedr- r- r. test_power_plugged s
z%TestSensorsBattery.test_power_pluggedc
s` fdd}t trdnd}tj||d,}| jtj jd | jtj jtj W d Q R X d S )Nc s2 | j ds| j dr tjdS | f||S d S )Nz
AC0/onlinez AC/online 1)r rs rt )rx ry rz )r{ r- r. r| s
z@TestSensorsBattery.test_emulate_power_plugged..open_mockz
builtins.openz__builtin__.open)r~ T)
r r r r r rZ rd ri ZsecsleftZPOWER_TIME_UNLIMITED)r] r| r r r- )r{ r. test_emulate_power_plugged s z-TestSensorsBattery.test_emulate_power_pluggedc
sL fdd}t trdnd}tj||d}| jtj jd W d Q R X d S )Nc sN | j ds| j dr"ttjdn(| j dr:tjtdS | f||S d S )Nz
AC0/onlinez AC/onliner2 z/statusZcharging)r r r r rs r r )rx ry rz )r{ r- r. r| s
zBTestSensorsBattery.test_emulate_power_plugged_2..open_mockz
builtins.openz__builtin__.open)r~ T)r r r r r rZ rd ri )r] r| r r r- )r{ r. test_emulate_power_plugged_2 s z/TestSensorsBattery.test_emulate_power_plugged_2c
sL fdd}t trdnd}tj||d}| jtj jd W d Q R X d S )Nc s2 | j ds| j dr tjdS | f||S d S )Nz
AC0/onlinez AC/online 0)r rs rt )rx ry rz )r{ r- r. r| s
zDTestSensorsBattery.test_emulate_power_not_plugged..open_mockz
builtins.openz__builtin__.open)r~ F)r r r r r rZ rd ri )r] r| r r r- )r{ r. test_emulate_power_not_plugged s z1TestSensorsBattery.test_emulate_power_not_pluggedc
sL fdd}t trdnd}tj||d}| jtj jd W d Q R X d S )Nc sN | j ds| j dr"ttjdn(| j dr:tjtdS | f||S d S )Nz
AC0/onlinez AC/onliner2 z/statusZ discharging)r r r r rs r r )rx ry rz )r{ r- r. r| s
zFTestSensorsBattery.test_emulate_power_not_plugged_2..open_mockz
builtins.openz__builtin__.open)r~ F)r r r r r rZ rd ri )r] r| r r r- )r{ r. test_emulate_power_not_plugged_2 s z3TestSensorsBattery.test_emulate_power_not_plugged_2c sJ fdd}t trdnd}tj||d}| jtj j W d Q R X d S )Nc sJ | j ds| j dr"ttjdn$| j dr6tjdS | f||S d S )Nz"/sys/class/power_supply/AC0/onlinez!/sys/class/power_supply/AC/onliner2 z#/sys/class/power_supply/BAT0/statuss ???)rA r r r rs rt )rx ry rz )r{ r- r. r| s
zETestSensorsBattery.test_emulate_power_undetermined..open_mockz
builtins.openz__builtin__.open)r~ )r r r r r rZ rd ri )r] r| r r r- )r{ r. test_emulate_power_undetermined s z2TestSensorsBattery.test_emulate_power_undeterminedc sH fdd}t trdnd}tj||d}| jtj W d Q R X d S )Nc s6 | j ds| j dr"ttjdn | f||S d S )Nz'/sys/class/power_supply/BAT0/energy_nowz'/sys/class/power_supply/BAT0/charge_nowr2 )rA r r r )rx ry rz )r{ r- r. r| s
z@TestSensorsBattery.test_emulate_no_base_files..open_mockz
builtins.openz__builtin__.open)r~ )r r r r r rZ rd )r] r| r r r- )r{ r. test_emulate_no_base_files s z-TestSensorsBattery.test_emulate_no_base_filesc
sL fdd}t trdnd}tj||d}| jtj jd W d Q R X d S )Nc s( | j drtjdS | f||S d S )Nz(/sys/class/power_supply/BAT0/energy_fullrn )rA rs rt )rx ry rz )r{ r- r. r| & s
z@TestSensorsBattery.test_emulate_energy_full_0..open_mockz
builtins.openz__builtin__.open)r~ r )r r r r r rZ rd re )r] r| r r r- )r{ r. test_emulate_energy_full_0$ s z-TestSensorsBattery.test_emulate_energy_full_0c
sL fdd}t trdnd}tj||d}| jtj jd W d Q R X d S )Nc sR d}d}| j |s | j |r*ttjdn$| j dr>tjdS | f||S d S )Nz(/sys/class/power_supply/BAT0/energy_fullz(/sys/class/power_supply/BAT0/charge_fullr2 z%/sys/class/power_supply/BAT0/capacitys 88)rA r r r rs rt )rx ry rz Z energy_fullZ charge_full)r{ r- r. r| 5 s
zHTestSensorsBattery.test_emulate_energy_full_not_avail..open_mockz
builtins.openz__builtin__.open)r~ X )r r r r r rZ rd re )r] r| r r r- )r{ r. "test_emulate_energy_full_not_avail2 s
z5TestSensorsBattery.test_emulate_energy_full_not_availc s: fdd}t jj tjd|d}tj W d Q R X d S )Nc s | j drdS | S d S )Nz"/sys/class/power_supply/AC0/onlineF)rA )rx )orig_path_existsr- r. path_exists_mockG s
zGTestSensorsBattery.test_emulate_no_ac0_online..path_exists_mockz psutil._pslinux.os.path.exists)r~ )r r r r r rZ rd )r] rw r r- )rv r. test_emulate_no_ac0_onlineE s
z-TestSensorsBattery.test_emulate_no_ac0_onlinec sJ fdd}t trdnd}tj||d}| jtj j W d Q R X d S )Nc s@ | j ds | j ds | j dr,ttjdn | f||S d S )Nz!/sys/class/power_supply/AC/onlinez"/sys/class/power_supply/AC0/onlinez#/sys/class/power_supply/BAT0/statusr2 )rA r r r )rx ry rz )r{ r- r. r| U s
z;TestSensorsBattery.test_emulate_no_power..open_mockz
builtins.openz__builtin__.open)r~ )r r r r r rZ rd ri )r] r| r r r- )r{ r. test_emulate_no_powerS s z(TestSensorsBattery.test_emulate_no_powerN)r r r r r r rf rj rl rm ro rp rq rr rs ru rx ry r- r- r- r. r` s r` c @ s( e Zd Zejeddd Zdd ZdS )TestSensorsTemperatureszunreliable on TRAVISc sx fdd}t trdnd}tj||dD}tjdd,}| jtj i | j dt
|d j W d Q R X W d Q R X d S )
Nc s, | j drttjdn | f||S d S )NZ_inputr2 )r OSErrorr ZEIO)rx ry rz )r{ r- r. r| i s
zATestSensorsTemperatures.test_emulate_eio_error..open_mockz
builtins.openz__builtin__.open)r~ T)r Zignoringr ) r r r r r r r rZ sensors_temperaturesr r r )r] r| r r r r- )r{ r. test_emulate_eio_errorg s z.TestSensorsTemperatures.test_emulate_eio_errorc s fdd}t trdnd}tj||dj tjddgdN tj d d
}| j|jd | j|jd | j|j d
| j|j
d W d Q R X W d Q R X d S )Nc s | j drtjtdS | j dr0tjtdS | j drDtjdS | j drXtjdS | j d rltjd
S | f||S d S ) Nz/namerx z /temp1_labellabelz /temp1_inputs 30000z
/temp1_maxs 40000z /temp1_crits 50000)r rs r r rt )rx ry rz )r{ r- r. r| x s
z.open_mockz
builtins.openz__builtin__.open)r~ z glob.globz /sys/class/hwmon/hwmon0/temp1)r rx r r~ g >@g D@g I@) r r r r rZ r| r r~ r ZhighZcritical)r] r| r Ztempr- )r{ r. test_emulate_dataw s z)TestSensorsTemperatures.test_emulate_dataN)r r r r r r r} r r- r- r- r. rz d s rz c @ s e Zd Zdd ZdS )TestSensorsFansc s fdd}t trdnd}tj||dN tjddgd2 tj d d
}| j|jd | j|jd W d Q R X W d Q R X d S )
Nc s\ | j drtjtdS | j dr0tjtdS | j drHtjtdS | f||S d S )Nz/namerx z /fan1_labelr~ z /fan1_inputZ2000)r rs r r )rx ry rz )r{ r- r. r| s
z4TestSensorsFans.test_emulate_data..open_mockz
builtins.openz__builtin__.open)r~ z glob.globz /sys/class/hwmon/hwmon2/fan1)r rx r r~ i ) r r r r rZ Z sensors_fansr r~ r )r] r| r Zfanr- )r{ r. r s
z!TestSensorsFans.test_emulate_dataN)r r r r r- r- r- r. r s r c @ s e Zd Zdd ZeZdd Zejeddd Z dd Z
d
d Z d d
Z dd Z
dd Zdd Zdd Zdd Zdd Zeje ddd Zd d Zd d Zd!d" Zd#S )$ TestProcessc C s t t d S )N)r r )r] r- r- r. setUp s zTestProcess.setUpc C s t jdt }t|}| jt tdd dt tj|j }t
j d |j }|j
dd}| j|jtdd |D d
d | j|jtd d |D d
d | j|jtd
d |D d
d d S )Nzk
import time
with open("%s", "w") as f:
time.sleep(10)
c S s
t jdS )NrU )r r r- r- r- r. s z3TestProcess.test_memory_full_info..z'%s' not in retg?F)Zgroupedc S s g | ]}|j |j qS r- )Z
private_dirtyZ
private_clean)r3 r0 r- r- r. r5 s z5TestProcess.test_memory_full_info..i )rc c S s g | ]
}|j qS r- )pss)r3 r0 r- r- r. r5 s c S s g | ]
}|j qS r- )r )r3 r0 r- r- r. r5 s )ru rv r r
r r r rZ rO pidtimeZsleepZmemory_full_info memory_mapsr\ ZussrB r r )r] srcZsprocr[ Zmemmapsr- r- r. test_memory_full_info s
z!TestProcess.test_memory_full_infozunreliable on PYPYc ; C sR dd }t td | j| jd W d Q R X t td | j| jd W d Q R X t td | j| jd W d Q R X t td | j| jd W d Q R X t td | j| jd W d Q R X t td | j| jd W d Q R X trNtt t td | j| jd W d Q R X tt t td
| j| jd W d Q R X d S ) Nc S s\ t j } tj d }x:x4| j D ](}|jtjjtkr:|S tj |kr P q W qW tdd S )Nr z timeout looking for test file) rZ rO r
open_filesr r abspathr r )r[ Z giveup_atfiler- r- r.
get_test_file s
z7TestProcess.test_open_files_mode..get_test_filer r! r zr+zw+za+r0 zx+)r r r moder r )r] r r- r- r. test_open_files_mode s( z TestProcess.test_open_files_modec C s t j }|j }tj v t|jdt| tjdt t
j dd}|j }W d Q R X tjdt t
j dd}| j
|j g W d Q R X W d Q R X d S )Nzlen(ret) != %izpsutil._pslinux.os.readlinkr2 )r~ )rZ rO r r> NamedTemporaryFiler r r r r{ r r ZEINVALr )r] r[ filesr r- r- r. test_open_files_file_gone s
z%TestProcess.test_open_files_file_gonec C sr t j }|j }tj P t|jdt| tr6dnd}tj |t
t j dd}|j }W d Q R X W d Q R X d S )Nzlen(ret) != %iz
builtins.openz__builtin__.openr2 )r~ )
rZ rO r r> r r r r r r r r r )r] r[ r r r r- r- r. test_open_files_fd_gone s
z#TestProcess.test_open_files_fd_gonec
C s8 t jdi d }| jtjjtj j W d Q R X d S )Nz)psutil._pslinux._psposix.get_terminal_map)r ) r r r rZ r rO r r^ Zterminal)r] r r- r- r. test_terminal_mocked s
z TestProcess.test_terminal_mockedc C s t j }tjtd}tjd|dd}| j|j ddg W d Q R X tjtd}tjd|dd }| j|j dddg W d Q R X d S ) Nzfoo bar zpsutil._pslinux.openT)r r} rL barz foo bar r2 ) rZ rO rs r r r r r cmdline)r] r[ r r r- r- r. test_cmdline_mocked% s
z TestProcess.test_cmdline_mockedc C s t j }tjtd}tjd|dd}| j|j ddg W d Q R X tjtd}tjd|dd }| j|j dddg W d Q R X d S ) Nzfoo bar zpsutil._pslinux.openT)r r} rL r z foo bar r2 ) rZ rO rs r r r r r r )r] r[ r r r- r- r. test_cmdline_spaces_mocked3 s
z&TestProcess.test_cmdline_spaces_mockedc
C sF t jddd. | jtj j d | jtj j d W d Q R X d S )Nzpsutil._pslinux.os.readlinkz/home/foo (deleted))r z /home/foo)r r r rZ rO execwd)r] r- r- r. !test_readlink_path_deleted_mockedA s
z-TestProcess.test_readlink_path_deleted_mockedc s fdd}t trdnd}tj||d }tj j }| j|g W d Q R X fdd}tj||d | jtj tj j W d Q R X d S )Nc s4 | j dtj r ttjdn | f||S d S )Nz
/proc/%s/taskr2 )rA r r^ r r r )rx ry rz )r{ r- r. r| L s z2TestProcess.test_threads_mocked..open_mockz
builtins.openz__builtin__.open)r~ c s4 | j dtj r ttjdn | f||S d S )Nz
/proc/%s/taskr2 )rA r r^ r r ZEPERM)rx ry rz )r{ r- r. r| [ s )
r r r r rZ rO rW r r AccessDenied)r] r| r r r r- )r{ r. test_threads_mockedG s z TestProcess.test_threads_mockedc C s t jdttjddn}t jdtjdddL}tj j }| j |d t jddd | j
tj tj j W d Q R X W d Q R X W d Q R X d S ) Nzpsutil._pslinux.readlinkr2 )r~ zpsutil.Process.cmdliner z psutil._pslinux.os.path.lexistsF)r ) r r r{ r r rZ r rO r r r
ZombieProcess)r] r& r' r r- r- r. test_exe_mockedd s
zTestProcess.test_exe_mockedc sr fdd}t trdnd}tj||d>}tj }| jt}|j W d Q R X | j |j
j t j W d Q R X d S )Nc s4 | j dtj r ttjdn | f||S d S )Nz/proc/%s/smapsr2 )rA r r^ r r r )rx ry rz )r{ r- r. r| | s z.TestProcess.test_issue_1014..open_mockz
builtins.openz__builtin__.open)r~ )
r r r r rZ rO r r r r exceptionr r )r] r| r r r[ errr- )r{ r. test_issue_1014y s zTestProcess.test_issue_1014z
not supportedc C s t jdttjdd:}tj }|j | jtj }|j
tj W d Q R X W d Q R X | j |j
j|j | j |j
j|j d S )Nz"psutil._pslinux.cext.linux_prlimitr2 )r~ )r r r{ r ZENOSYSrZ rO rx r r ZrlimitZ
RLIMIT_NOFILEr r r )r] r r[ excr- r- r. test_rlimit_zombie s
z TestProcess.test_rlimit_zombiec C s| t jdttjdd6}tj }|j | jtj }|j
W d Q R X W d Q R X | j |j j
|j
| j |j j|j d S )Nzpsutil._pslinux.os.readlinkr2 )r~ )r r r{ r r rZ rO rx r r r r r r )r] r r[ r r- r- r. test_cwd_zombie s
zTestProcess.test_cwd_zombiec s ddl m} fdd}t tr$dnd}tj||d tj }| j|j d | j|j
tj | j|j d | j|j
d
| tj |j }| j|jd | | j|jd | | j|jd
| | j|jd| | j|j d
W d Q R X d S )Nr ) CLOCK_TICKSc ' s | j dtj rxddddddddddddddddd ddddd
ddddddddddddddddd
g'}tjd j|j S | f||S d S ) Nz
/proc/%s/stat0z(cat)Z123456rQ )rA r r^ rs rt r; rw )rx ry rz )r{ r- r. r| sT z5TestProcess.test_stat_file_parsing..open_mockz
builtins.openz__builtin__.open)r~ catr7 r r ra r rN )r r r r r r rZ rO r rx statusZ
STATUS_ZOMBIEppidZ create_timer; r usersystem
children_userchildren_systemZcpu_num)r] r r| r r[ Zcpur- )r{ r. test_stat_file_parsing s" / z"TestProcess.test_stat_file_parsingc
s fdd}t trdnd}tj||d tj }| j|j jd | j|j j d | j|j
d |j }| j|j d | j|j
d
| j|jd |j }| j|j d | j|j
d
| j|jd | j|jj ttdd W d Q R X d S )Nc s: | j dtj r&tjtjdj S | f||S d S )Nz/proc/%s/statusa+ Uid: 1000 1001 1002 1003
Gid: 1004 1005 1006 1007
Threads: 66
Cpus_allowed: f
Cpus_allowed_list: 0-7
voluntary_ctxt_switches: 12
nonvoluntary_ctxt_switches: 13)rA r r^ rs rt ru rv rw )rx ry rz )r{ r- r. r| s z7TestProcess.test_status_file_parsing..open_mockz
builtins.openz__builtin__.open)r~ rb
B i i i i i i r r* )r r r r rZ rO r num_ctx_switches voluntary involuntary num_threadsuidsrealZ effectiveZsavedgids_proc_get_eligible_cpuslistrange)r] r| r r[ r r r- )r{ r. test_status_file_parsing s"
z$TestProcess.test_status_file_parsingN)r r r r ZtearDownr r r r r r r r r r r r r r r r r r r r- r- r- r. r s" $ Br c @ sr e Zd ZdZedd Zdd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z e
dd Zdd Zdd ZdS )TestProcessAgainstStatusa /proc/pid/stat and /proc/pid/status have many values in common.
Whenever possible, psutil uses /proc/pid/stat (it's faster).
For all those cases we check that the value found in
/proc/pid/stat (by psutil) matches the one found in
/proc/pid/status.
c C s t j | _d S )N)rZ rO proc)clsr- r- r.
setUpClass s z#TestProcessAgainstStatus.setUpClassc C s| t jjd| jj ^}xJ|D ]B}|j }|j|r |jdd }yt|S t k
r\ |S X q W t d| W d Q R X d S )Nz/proc/%s/status r z
can't find %r)
rZ _psplatform open_textr r rR rA partitionrD rE )r] Z linestartr rH r r- r- r. read_status_file s
z)TestProcessAgainstStatus.read_status_filec C s | j d}| j| jj | d S )NzName:)r r r rx )r] r r- r- r. test_name! s
z"TestProcessAgainstStatus.test_namec C sH | j d}||jdd |jd }|jdd}| j| jj | d S )NzState:(r7 )rQ r )r findrfindrc r r r )r] r r- r- r. test_status% s
z$TestProcessAgainstStatus.test_statusc C s | j d}| j| jj | d S )NzPPid:)r r r r )r] r r- r- r. test_ppid+ s
z"TestProcessAgainstStatus.test_ppidc C s | j d}| j| jj | d S )NzThreads:)r r r r )r] r r- r- r. test_num_threads/ s
z)TestProcessAgainstStatus.test_num_threadsc C s: | j d}ttt|j dd }| j| jj | d S )NzUid:r7 r )r rV rW rD r@ r r r )r] r r- r- r. test_uids3 s
z"TestProcessAgainstStatus.test_uidsc C s: | j d}ttt|j dd }| j| jj | d S )NzGid:r7 r )r rV rW rD r@ r r r )r] r r- r- r. test_gids8 s
z"TestProcessAgainstStatus.test_gidsc C s@ | j d}| j| jj j| | j d}| j| jj j| d S )Nzvoluntary_ctxt_switches:znonvoluntary_ctxt_switches:)r r r r r r )r] r r- r- r. test_num_ctx_switches= s
z.TestProcessAgainstStatus.test_num_ctx_switchesc C sN | j d}dt|krJtt|jd\}}| j| jj tt ||d d S )NzCpus_allowed_list:r r7 )
r r rW rD r@ r r Z cpu_affinityr r )r] r Zmin_Zmax_r- r- r. test_cpu_affinityD s
z*TestProcessAgainstStatus.test_cpu_affinityc
C s> | j d}tjd}| jjj W d Q R X dt|kr:n d S )NzCpus_allowed_list:z psutil._pslinux.per_cpu_timesr )r r r r r r r )r] r r r- r- r. test_cpu_affinity_eligible_cpusK s
z8TestProcessAgainstStatus.test_cpu_affinity_eligible_cpusN)r r r __doc__ classmethodr r r r r r r r r r r r r- r- r- r. r s
r c @ s, e Zd Zdd Zdd Zdd Zdd Zd S )
TestUtilsc
C s* t jjt}| j|jd W d Q R X d S )NZrt)rZ r r __file__r r )r] r r- r- r. test_open_text] s zTestUtils.test_open_textc
C s* t jjt}| j|jd W d Q R X d S )Nr )rZ r r r r r )r] r r- r- r. test_open_binarya s zTestUtils.test_open_binaryc
C s2 t jddd}| jtjjdd W d Q R X d S )Nz os.readlinkz
foo (deleted))r r rL )r r r rZ r readlink)r] r r- r- r.
test_readlinke s zTestUtils.test_readlinkc C s| t jjt}t|d}|jd W d Q R X | jtjj tddd | jtjj tddd | jtjj td d d
d d S ) NZwtzfoo F)ZbinaryrL Ts fooz??r )Zfallback)
r r r r r r@ r rZ r r )r] Zfnamer r- r- r. test_catj s zTestUtils.test_catN)r r r r r r r r- r- r- r. r Z s r __main__)Kr Z
__future__r rB r$ r r rs r r
r rC r! r) r> ru r r rZ r Zpsutil._compatr r Z psutil.testsr r r r r
r r r
r r r r r r r r r r r r r r dirnamer ZHEREr( Z SIOCGIFCONFr9 r/ r/ r= rM rP rT rX r ZTestCaserY r r r r r r: r` rz r r r r r r- r- r- r. s
k
T
t
. 7
-
Y
R
PK ! V% # __pycache__/test_aix.cpython-36.pycnu [ 3
JZm @ sx d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlZeje dG dd d ej Z
e d
krtee dS ) zAIX specific tests. N)AIX)run_test_module_by_name)sh)unittestzAIX onlyc @ s4 e Zd Zdd Zdd Zdd Zdd Zd d
Zd S ) AIXSpecificTestCasec C s t d}d}x dj D ]}|d|f 7 }qW tj||}| j|d d}t|jd| }t|jd| }t|jd | }t|jd
| } tj }
d | | } | j |
j
| | j |
j || d | j |
j
|| d | j |
j| | d d S )
Nz/usr/bin/svmon -O unit=KBz memory\s*z+size inuse free pin virtual available mmodez(?P<%s>\S+)\s+z(svmon command returned unexpected outputi size availableZinusefree )delta)r splitresearchassertIsNotNoneintgrouppsutilZvirtual_memory assertEqualtotalassertAlmostEqualusedr r ) selfout
re_patternfieldmatchobjZKBr r r r
psutil_resultZMEMORY_TOLERANCE r /usr/lib64/python3.6/test_aix.pytest_virtual_memory s* z'AIXSpecificTestCase.test_virtual_memoryc C sT t d}tjd|}| j|d t|jd}d}tj }| jt|j | | d S )Nz/usr/sbin/lsps -az=(?P\S+)\s+(?P\S+)\s+(?P\S+)\s+(?P\d+)MBz'lsps command returned unexpected outputr i r
i )
r r
r r r r r Z swap_memoryr r )r r r Ztotal_mbZMBr r r r test_swap_memory4 s z$AIXSpecificTestCase.test_swap_memoryc C s t d}d}x dj D ]}|d|f 7 }qW tj||}| j|d d}tj }| j|jt |j
d|d | j|j t |j
d |d | j|j t |j
d
|d | j|j
t |j
d |d d S ) Nz/usr/bin/mpstat -azALL\s*zfmin maj mpcs mpcr dev soft dec ph cs ics bound rq push S3pull S3grd S0rd S1rd S2rd S3rd S4rd S5rd syscz(?P<%s>\S+)\s+z)mpstat command returned unexpected outputi Zcs)r ZsyscZdevZsoft)r r r
r r r Z cpu_statsr Z ctx_switchesr r ZsyscallsZ
interruptsZsoft_interrupts)r r r r r ZCPU_STATS_TOLERANCEr r r r test_cpu_statsI s2 z"AIXSpecificTestCase.test_cpu_statsc C s: t d}ttjd|jd}tjdd}| j|| d S )Nz/usr/bin/mpstat -az
lcpu=(\d+) T)Zlogical)r r r
r r r cpu_countr )r r Z mpstat_lcpuZ psutil_lcpur r r test_cpu_count_logicalj s z*AIXSpecificTestCase.test_cpu_count_logicalc C s4 t d}t|j }ttj j }| j|| d S )Nz/etc/ifconfig -l)r setr r Z net_if_addrskeysZassertSetEqual)r r Zifconfig_namesZ psutil_namesr r r test_net_if_addrs_namesp s z+AIXSpecificTestCase.test_net_if_addrs_namesN)__name__
__module__ __qualname__r r r! r$ r' r r r r r s
!r __main__)
__doc__r
r r Z psutil.testsr r r ZskipIfZTestCaser r( __file__r r r r s
cPK ! Z$d?d@ Z%dAdB Z&dCdD Z'dEdF Z(dGdH Z)e j e*dIdJdK Z+e j e,o\e-j.j/dL dMe j e0ote1j2 dNkdOdPdQ Z3dRdS Z4e j e0pe*oe1j5 dTdUdV Z6dWdX Z7e j e8 dYdZd[ Z9d\d] Z:e j e; d^d_d` Z d^e j e? dcddde Z@e j eA d^dfdg ZBdNS )hTestSystemAPIsz Tests for system-related APIs.c C s t t d S )N)r r )self r# #/usr/lib64/python3.6/test_system.pysetUp> s zTestSystemAPIs.setUpc C s
t d S )N)r )r" r# r# r$ tearDownA s zTestSystemAPIs.tearDownc C s | j tj dd tj D t }| j |jdd tj D tj|j}|j |j | j
|jdd tj D t j dtj
tj d | jttj g W d Q R X t j dtjtj d* | jtj ttj W d Q R X W d Q R X d S )Nc S s g | ]
}|j qS r# )pid).0xr# r# r$
E s z4TestSystemAPIs.test_process_iter..c S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* G s c S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* K s zpsutil.Process) side_effect)assertInosgetpidpsutil process_iterr r' Processkillwait assertNotInr patchZ
NoSuchProcess assertEquallist AccessDenied assertRaises)r" sprocpr# r# r$ test_process_iterD s z TestSystemAPIs.test_process_iterc C s8 x.t jdgdD ] }| jt|jj dg qW | jt tt jdgd W d Q R X tj dt j
dddL}x:t jddgdD ]&}| j |jd | j |jd d qW |j
stW d Q R X tj dt j
dddX}t }x>t jddg|d D ](}| j|jd | | j |jd d qW |j
s*tW d Q R X d S )
Nr' )attrsZfooz$psutil._psplatform.Process.cpu_timesr )r+ cpu_times)r= Zad_value)r/ r0 r6 r7 infokeysr9
ValueErrorr r5 r8 assertIsNoneassertGreaterEqualcalledAssertionErrorobjectassertIs)r" r; mflagr# r# r$ test_prcess_iter_w_paramsU s$ z(TestSystemAPIs.test_prcess_iter_w_paramsc s fdd}g t }t }t }dd |||fD }jttj|dd jttj|dd tj }tj|d|d \}}jtj | d
j|g jt |d j g x |D ]} j
t | d qW t d
fdd}
|j
|
||\}}j|jdd |D tr4j|j jtj nj|j jd j |jg x |D ]} j
t | d q\W t d
fdd}
|j
|j
|
||\}}jt t|j|j|jg x |D ]} jt | d qW d S )Nc s j | j d S )N)appendr' )r; )pidsr# r$ callbackj s z0TestSystemAPIs.test_wait_procs..callbackc S s g | ]}t j|jqS r# )r/ r1 r' )r( r) r# r# r$ r* q s z2TestSystemAPIs.test_wait_procs.. )timeout)rN g{Gz?)rP rN g ?
returncode c s< t j| d|d\}} jt|d jt|d ||fS )Ng Q?)rP rN rO )r/
wait_procsr6 len)procsrN gonealive)r" r# r$ test~ s
z,TestSystemAPIs.test_wait_procs..testc S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* s c s< t j| d|d\}} jt|d jt|d ||fS )Ng Q?)rP rN rQ r )r/ rU r6 rV )rW rN rX rY )r" r# r$ rZ s
)r r9 rB r/ rU TypeErrortime
assertLessr6 rV assertFalsehasattrr terminater, r' r poprR signalSIGTERMset
assertTrue) r" rN sproc1sproc2sproc3rW trX rY r; rZ r# )rM r" r$ test_wait_procsi sB
z TestSystemAPIs.test_wait_procsc C sN t }t }t }dd |||fD }x|D ] }|j q,W tj|\}}d S )Nc S s g | ]}t j|jqS r# )r/ r1 r' )r( r) r# r# r$ r* s z=TestSystemAPIs.test_wait_procs_no_timeout..)r ra r/ rU )r" rg rh ri rW r; rX rY r# r# r$ test_wait_procs_no_timeout s
z)TestSystemAPIs.test_wait_procs_no_timeoutc C s4 t j }| j|t | j|d | j|tj d S )Nr )r/ Z boot_timeassertIsInstancefloat
assertGreaterr^ r] )r" Zbtr# r# r$ test_boot_time s z TestSystemAPIs.test_boot_timez
POSIX onlyc C s" dd l }| jtjd|j d S )Nr SC_PAGE_SIZE)resourcer6 r- sysconfZ getpagesize)r" rr r# r# r$
test_PAGESIZE s z TestSystemAPIs.test_PAGESIZEc C s t j }|jdkst||jdks,t|d|j ko@dkn sNt||jdks`t||jdksrt|xt|jD ]j}t ||}|dkr| j
|t t f |dkrz|dks| j
d||f ||jkrz| j
d||j||f qzW d S )Nr d percenttotalz %r < 0 (%s)z %r > total (total=%s, %s=%s))r/ Zvirtual_memoryrw rF Z availablerv usedfree_fieldsgetattrrm intr fail)r" memnamevaluer# r# r$ test_virtual_memory s "
z"TestSystemAPIs.test_virtual_memoryc C s t j }| j|jd |jdks(t||jdks:t||jdkrX|jdksjt|n|jdksjt|d|j ko~dkn st||j dkst||j
dkst|d S )
Nrw rx ry rv sinsoutr ru )rw rx ry rv r r ) r/ Z swap_memoryr6 rz rw rF rx ry rv r r )r" r~ r# r# r$ test_swap_memory s
"z TestSystemAPIs.test_swap_memoryc C st t }| jtj|j tj|j}|j |j | jtj|j | jtjd | j tjddtj
k d S )NrO r r[ ) r rf r/
pid_existsr' r1 r2 r3 r_ r6 rM )r" r: r; r# r# r$ test_pid_exists s z TestSystemAPIs.test_pid_existsc C s t tj }xT|D ]L}ytj|s(tW q tk
r^ tjd |tj krZ| j| Y qX qW tt |d t |d }x |D ]}| j
tj||d qW d S )Ng?i ip )msg) r r/ rM r rF r] sleepr} rangemaxr_ )r" rM r' r# r# r$ test_pid_exists_2 s
z TestSystemAPIs.test_pid_exists_2c C sJ dd t j D }t j }| j|j |j | jt|tt| d S )Nc S s g | ]
}|j qS r# )r' )r( r) r# r# r$ r* s z,TestSystemAPIs.test_pids..)r/ r0 rM r6 sortrV re )r" ZplistZpidlistr# r# r$ test_pids s zTestSystemAPIs.test_pidsc C s& t j}tt _z tj W d |t _X d S )N)sysstdoutr r/ rZ )r" r r# r# r$ test_test s
zTestSystemAPIs.test_testc
C s t j }| j|tt jdd | j|d tjjdrft d}|j
}W d Q R X d|krft j dt jdd}| j|d | j|| d S ) NT)percpurO z
/proc/cpuinfoz physical idz#cpuinfo doesn't include physical idF)logical)
r/ cpu_countr6 rV r? rD r- pathexistsopenreadr ZSkipTest)r" r fdZ cpuinfo_dataZphysicalr# r# r$ test_cpu_count s
z TestSystemAPIs.test_cpu_countc C sz xtd D ]l}t jd|d }| jtj |js2tW d Q R X t jd|d"}| jtjdd |jshtW d Q R X qW d S )
NrO r z$psutil._psplatform.cpu_count_logical) return_valuez%psutil._psplatform.cpu_count_physicalF)r r[ )r[ r N)r r5 rC r/ r rE rF )r" valrI r# r# r$ test_cpu_count_none s
z"TestSystemAPIs.test_cpu_count_nonec C s^ d}t j }t| x,|D ]$}| j|t | j|d ||7 }qW | j|t| t| d S )Nr g )r/ r? sumrm rn rD r6 str)r" rw timescp_timer# r# r$ test_cpu_times s
z TestSystemAPIs.test_cpu_timesc C sD t tj }tjd t tj }|| }|dks@| jd| d S )Ng?g?z
difference %s)r r/ r? r] r r} )r" t1t2
differencer# r# r$ test_cpu_times_time_increases: s
z,TestSystemAPIs.test_cpu_times_time_increasesc C s xft jddD ]V}d}t| x,|D ]$}| j|t | j|d ||7 }q$W | j|t| t| qW | jtt jddd tt jdd d S )NT)r r g F) r/ r? r rm rn rD r6 r rV )r" r rw r r# r# r$ test_per_cpu_timesC s
z!TestSystemAPIs.test_per_cpu_timesc C s t jdd}tj d }xtj |krP qW t jdd}x.rO )delta)r/ r? _maker rz assertAlmostEqualr{ )r" baseZper_cpuZ
summed_valuesZfieldr# r# r$ test_cpu_times_comparisont s z(TestSystemAPIs.test_cpu_times_comparisonc C s y<| j |t | j|d | j|d | j|dtj W n@ tk
r| } z$td|tj |tj |f W Y d d }~X nX d S )Ng g Y@z
%s
last=%s
new=%sg )
rm rn rD Z assertIsNotassertLessEqualr/ r rF pprintZpformat)r" rv Zlast_retZnew_reterrr# r# r$ _test_cpu_percent~ s z TestSystemAPIs._test_cpu_percentc
C sb t jdd}x.tdD ]"}t jd d}| j||| |}qW | jt t jdd W d Q R X d S )NgMbP?)intervalru rO r[ )r/ cpu_percentr r r9 rB )r" lastr) newr# r# r$ test_cpu_percent s z TestSystemAPIs.test_cpu_percentc C s t jddd}| jt|t j x>tdD ]2}t jd dd}x|D ]}| j||| qDW |}q,W | jt t jddd W d Q R X d S )NgMbP?T)r r ru rO r[ ) r/ r r6 rV r r r r9 rB )r" r r) r rv r# r# r$ test_per_cpu_percent s
z#TestSystemAPIs.test_per_cpu_percentc C s` t jdd}xNtdD ]B}t jd d}x|D ]}| j||| q,W | jt||| |}qW d S )NgMbP?)r ru )r/ cpu_times_percentr r r )r" r r) r rv r# r# r$ test_cpu_times_percent s
z%TestSystemAPIs.test_cpu_times_percentc C s t jddd}| jt|t j x^tdD ]R}t jd dd}x:|D ]2}x|D ]}| j||| qNW | jt||| qDW |}q,W d S )NgMbP?T)r r ru )r/ r r6 rV r r r r )r" r r) r cpurv r# r# r$ test_per_cpu_times_percent s
z)TestSystemAPIs.test_per_cpu_times_percentc
C sr t jdd dd t jddD }tjd|d8 x0t jddD ] }x|D ]}| j|d d qJW q@W W d Q R X d S )NT)r c S s* g | ]"}|j d d tt|jD qS )c S s g | ]}d qS )r r# )r( r) r# r# r$ r* s zQTestSystemAPIs.test_per_cpu_times_percent_negative...)r r rV rz )r( r) r# r# r$ r* s zFTestSystemAPIs.test_per_cpu_times_percent_negative..zpsutil.cpu_times)r )r/ r r? r r5 r )r" Z
zero_timesr rv r# r# r$ #test_per_cpu_times_percent_negative s
z2TestSystemAPIs.test_per_cpu_times_percent_negativec
C s2 t jtj }| j|jd |jdks.t||jdks@t||j dksRt||j|jksft||j|j kszt|d|j
kodkn st|j
t t d rt jtj }d
}| j|j|j | j
|j |j |d
| j
|j|j|d
tj }| jt}t j| W d Q R X | j|jjtj d S )Nrw rx ry rv r ru
disk_usage i )r )rw rx ry rv i i P )r/ r r- getcwdr6 rz rw rF rx ry rv r` shutilr tempfileZmktempr9 OSErrorZ exceptionerrnoENOENT)r" ZusageZ shutil_usageZ toleranceZfnameexcr# r# r$ test_disk_usage s( $ z TestSystemAPIs.test_disk_usagec C s( t r$| jt tjt W d Q R X d S )N)r r9 UnicodeEncodeErrorr/ r r )r" r# r# r$ test_disk_usage_unicode s z&TestSystemAPIs.test_disk_usage_unicodec C s t jd d S )N .)r/ r )r" r# r# r$ test_disk_usage_bytes s z$TestSystemAPIs.test_disk_usage_bytesc C s t jdd}| j||d x|D ]}| j|jt | j|jt | j|jt | j|jt t rld|jkrlq t
st j j
|jst|n|j tstrt j j
|jst|nt j j|jst||js t|q W t jdd}| j||d xt jddD ]}t syt j|j W nX tk
rp } z:trJtrJ|jtjkrJ w|jtjtjfkr` W Y d d }~X n@X ts~trt j j
|jst|nt j j|jst|| j|jt | j|jt qW dd }|t}dd t jddD }| j|| t j| d S )
NF)all)r ZcdromTc S s2 t jj| } x t jj| s(t jj| } qW | j S )N)r- r abspathismountdirnamelower)r r# r# r$ find_mount_point s z=TestSystemAPIs.test_disk_partitions..find_mount_pointc S s g | ]}|j j qS r# )
mountpointr )r( r) r# r# r$ r* s z7TestSystemAPIs.test_disk_partitions..) r/ Zdisk_partitionsrf rm Zdevicer r ZfstypeZoptsr r r- r r rF r
r isdirstatr r r ZEIOZEPERMZEACCES__file__r, r )r" lsZdiskr r ZmountZmountsr# r# r$ test_disk_partitions sL
z#TestSystemAPIs.test_disk_partitionsc sl fdd}t jdd}|| t jdd} j|g x.|D ]&} j| j|t ||| q>W d S )Nc s( j | d | j j | d | j j | d | j j | d | j j | d | j j | d | j j | d | j j | d | j | jdkst | | jdkst | | jdkst | | jdkst | | jdkst | | jdkst | | jdkst | | jdks$t | d S ) Nr rO rT rQ r )
r6 Z
bytes_sentZ
bytes_recvZ packets_sentZ packets_recvZerrinZerroutZdropinZdropoutrF )nt)r" r# r$ check_ntuple s z9TestSystemAPIs.test_net_io_counters..check_ntupleF)pernicT)r/ net_io_countersassertNotEqualrf rm r )r" r retkeyr# )r" r$ test_net_io_counters s
z#TestSystemAPIs.test_net_io_countersc C sN t jdi d6}| jtjdd | jtjddi |js@tW d Q R X d S )Nz"psutil._psplatform.net_io_counters)r F)r T)r r5 rC r/ r r6 rE rF )r" rI r# r# r$ test_net_io_counters_no_nics8 s
z+TestSystemAPIs.test_net_io_counters_no_nicsc
C st t j }|st|t j }ttjtjt jg}x|j D ]\}}| j
|t | j t
t|t
| x|D ]}| j
|jt | j
|jt | j
|jt td f | j
|jt td f | j|j| tjdkr| j
|jtj || jr|jtjkr6tj|j}tj| |j |jdf W d Q R X nj|jtjkrtj |jdtjtj dtj d }|\} }
} } }
tj| |
| }tj| |j |
W d Q R X xB|j|j|j|j fD ]*}|d k r|jtjkrt!||j qW |jr| j"|j qr|j rr| j"|j qrW q.check_ntupleF)perdiskzno disks on this system?TrO r[ r[ r[ )
r/ disk_io_countersrF r6 rV re r isdigitr4 rA )r" r r r r# )r" r$ test_disk_io_counters s
z$TestSystemAPIs.test_disk_io_countersc C sN t jdi d6}| jtjdd | jtjddi |js@tW d Q R X d S )Nz#psutil._psplatform.disk_io_counters)r F)r T)r r5 rC r/ r r6 rE rF )r" rI r# r# r$ test_disk_io_counters_no_disks s
z-TestSystemAPIs.test_disk_io_counters_no_disksz unreliable on APPVEYOR or TRAVISc C s t j }| j|g x|D ]}|js,t|| j|jt | j|jttd f |j d k rp| j|j ttd f |j |j |j
dkst|t j j |j
t
str| j|j qt j|j qW d S )Ng )r/ usersr r rF rm r Zterminalr hostZstarteddatetimeZ
fromtimestampr r rC r' r1 )r" r userr# r# r$
test_users s
zTestSystemAPIs.test_usersc C sZ t j }| j|jd x>|jD ]4}t||}| j|d t r |dkr | j|d q W d S )N ctx_switches
interruptssoft_interruptssyscallsr )r r r r )r r )r/ Z cpu_statsr6 rz r{ rD r ro )r" Zinfosr r r# r# r$ test_cpu_stats s
z TestSystemAPIs.test_cpu_statsz not suportedc s` fdd}t jdd}tr&| r&d S |s2t||t jddg tr\ jt|t j d S )Nc sh xb| D ]Z} j |jd j|j|j x6|jD ],}t||} j|ttt f j
|d q0W qW d S )Ncurrentminr r )r r
r ) r6 rz r r r r{ rm r| r rn rD )r r r r )r" r# r$ check_ls s
z.TestSystemAPIs.test_cpu_freq..check_lsT)r F)r/ Zcpu_freqr rF r r6 rV r )r" r r r# )r" r$
test_cpu_freq s
z TestSystemAPIs.test_cpu_freqc C s ddddddddd g }x"|D ]}| j tt|t|d
q W tjd krJtjsPttj s\t|j d d t
j j krtj
s~t|j d nd
t
j j krtjst| jtjtjtjgjdd |j d |j d |j d |j d n^dt
j j ks
dt
j j kr"tjst|j d n&dt
j j krntjs>t|j d n$tjsVttj sdt|j d x$|D ] }| jtt|d|d
qtW d S )Nr r r r r r r r r
)r posixlinuxZbsdTrO sunossolarisdarwinF)rm r{ r/ r r- r r rF r remover platformr r r r6 r r r countr
r rH )r" namesr r# r# r$ test_os_constants s>
z TestSystemAPIs.test_os_constantsz
not supportedc C s t j }x|j D ]x\}}| j|t xb|D ]Z}| j|jt |jd k rV| j|jd |jd k rn| j|jd |j d k r,| j|j d q,W qW d S )Nr )
r/ sensors_temperaturesr rm r labelr rD highcritical)r" tempsr entriesentryr# r# r$ test_sensors_temperatures) s
z(TestSystemAPIs.test_sensors_temperaturesc
C sp ddgi}t jd|dN}tjdd d d
}|js8t| j|jd | j|jd | j|j d
W d Q R X d S )NZcoretempr I@ N@ Q@z'psutil._psplatform.sensors_temperatures)r T)Z
fahrenheitr g ^@g a@g c@)r r r r! )
r r5 r/ r rE rF r6 r r r )r" drI r r# r# r$ #test_sensors_temperatures_fahreneit7 s
z2TestSystemAPIs.test_sensors_temperatures_fahreneitz
no batteryc C sp t j }| j|jd | j|jd |jt jt jfkrF| j|jd n|jt jkr^| j|j | j
|j t d S )Nr ru ) r/ Zsensors_batteryrD rv r ZsecsleftZPOWER_TIME_UNKNOWNZPOWER_TIME_UNLIMITEDrf Z
power_pluggedrm r )r" r r# r# r$ test_sensors_batteryC s
z#TestSystemAPIs.test_sensors_batteryc C sj t j }x\|j D ]P\}}| j|t x:|D ]2}| j|jt | j|jttf | j |jd q,W qW d S )Nr )
r/ Z sensors_fansr rm r r r r| r rD )r" Zfansr r r r# r# r$ test_sensors_fansQ s
z TestSystemAPIs.test_sensors_fans)C__name__
__module__ __qualname____doc__r% r& r< rK rk rl rp r ZskipIfr rt r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r- r r r
r/ r r r r r r r r r r r r# r r r$ r r% r# r# r# r$ r! ; sh 7
!
> <#
%
r! __main__)2r) r r r r- r r rc r r r r] r/ r r r r r r r r r
r Zpsutil._compatr Z psutil.testsr
r r r r r r r r r r r r r r r r r r r ZTestCaser! r& r r# r# r# r$ sh '
PK ! ,U U 2 __pycache__/test_memory_leaks.cpython-36.opt-1.pycnu [ 3
JZ=G @ s< d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z
ddl
m Z ddl
m
Z
ddl
mZ ddl
mZ ddl
mZ dd l
mZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddlm%Z% dd lm&Z& dd lm'Z' dd lm(Z( d Z)d Z*d!Z+e'rd"nd#Z,e
j-j.Z.e
j/ Z0e'rd"nd#Z,d$d% Z1d&d' Z2G d(d) d)e(j3Z4G d*d+ d+e4Z5G d,d- d-e5Z6G d.d/ d/e4Z7e8d0kr8e#e9 dS )1a)
Tests for detecting function memory leaks (typically the ones
implemented in C). It does so by calling a function many times and
checking whether process memory usage keeps increasing between
calls or over time.
Note that this may produce false positives (especially on Windows
for some reason).
)print_functionN)LINUX)OPENBSD)OSX)POSIX)SUNOS)WINDOWS)xrange)create_sockets)get_test_subprocess)HAS_CPU_AFFINITY) HAS_CPU_FREQ) HAS_ENVIRON)
HAS_IONICE)HAS_MEMORY_MAPS)HAS_PROC_CPU_NUM)HAS_PROC_IO_COUNTERS)
HAS_RLIMIT)HAS_SENSORS_BATTERY)HAS_SENSORS_FANS)HAS_SENSORS_TEMPERATURES)
reap_children)run_test_module_by_name) safe_rmpath)skip_on_access_denied)TESTFN)TRAVIS)unittesti i TFc C s t jto
tdS )Nz worthless on LINUX (pure python))r skipIfr SKIP_PYTHON_IMPL r! r! )/usr/lib64/python3.6/test_memory_leaks.py
skip_if_linuxF s
r# c C st d
}i }x(t |D ] \}}d |d d
> ||< qW x8t|D ],}| || kr>> bytes2human(10000)
'9.8K'
>>> bytes2human(100001221)
'95.4M'
KMGTPEZY
z%.2f%sz%sB)r$ r% r& r' r( r) r* r+ ) enumeratereversedfloat)nZsymbolsprefixisvaluer! r! r" bytes2humanK s r6 c @ sL e Zd ZdZeZeZeZ dd Z
dd Z dd Z e
dd Ze
d
d Zd S )
TestMemLeakzBase framework class which calls a function many times and
produces a failure if process memory usage keeps increasing
between calls or over time.
c C s t j d S )N)gccollect)selfr! r! r" setUpg s zTestMemLeak.setUpc s~ fdd}j ddp$j}j ddp6jj ddpHj}x"tdD ]}jf qTW jtjg jt j
d jt j g | j
}| j
} | | }
|
|krzd } tj | } x,tj | krjf | d7 } qW ~ tj j
}
|
| }|
| krzt|
| }td
| tjd d }|d
7 }|t|
t|| |f }j| dS )zTest a callable.c s2 x"t D ]} jf q
W ~ tj d S )N)r _callr8 r9 )x)argsfunkwargsloopsr: r! r" call_many_timesl s z,TestMemLeak.execute..call_many_times
tolerance_NZloops_Z
retry_for_r- r, r zexta proc mem: %s)filez0+%s after %s calls, +%s after another %s calls, z+%s extra proc mem)pop tolerancerA retry_forranger< Z assertEqualr8 Zgarbage threadingZ active_countthisprocchildren_get_memtimer9 r6 printsysstderrZfail)r: r? r> r@ rB rF rG r= Zmem1Zmem2Zdiff1ZncallsZstop_atZmem3Zdiff2Zextra_proc_memmsgr! )r> r? r@ rA r: r" executej sB
zTestMemLeak.executec s" fdd}j | dS )zRConvenience function which tests a callable raising
an exception.
c s j f d S )N)Z assertRaisesr! )r> excr? r@ r: r! r" call s z'TestMemLeak.execute_w_exc..callN)rR )r: rS r? r> r@ rT r! )r> rS r? r@ r: r"
execute_w_exc s zTestMemLeak.execute_w_excc C s$ t s ts trtj jS tj jS d S )N)r r r rJ memory_full_infoZuss memory_infoZrssr! r! r! r" rL s
zTestMemLeak._get_memc O s | || d S )Nr! )r? r> r@ r! r! r" r< s zTestMemLeak._callN)__name__
__module__ __qualname____doc__MEMORY_TOLERANCErF LOOPSrA RETRY_FORrG r; rR rU staticmethodrL r< r! r! r! r" r7 ^ s ; r7 c @ s e Zd ZdZeZdd Ze dd Ze dd Z e dd Z
e d
d Z e j
e d e d
d Ze j
e d e dd Ze dd Zdd Zdd Ze j
e ddd Ze j
e ddd Ze j
e de d d Ze j
ed d d Ze d!d" Ze ee d#d$d% Z e j
e d&d'd( Z e j
e d e d)d* Z e d+d, Z!e ee d#d-d. Z"e d/d0 Z#e e j
e$ dd1d2 Z%e d3d4 Z&e d5d6 Z'e j
e d e d7d8 Z(e j
eoe)d9d:d; Z*e dd? Z-e j
e, dd@dA Z.e dBdC Z/e j
e0dDe j
e1 de dEdF Z2e j
e3 dGe j
e4 ddHdI Z5e j
e3 dGe j
e4 ddJdK Z6e e j
e dLdMdN Z7e j
e8 ddOdP Z9e j
e d&dQdR Z:dSS )TTestProcessObjectLeaksz$Test leaks of Process class methods.c C sN t d}x@ttjD ]2}|jdr$q||kr.q| jt| d| |d qW d S )Npidas_dictrK cpu_affinity cpu_percentionice
is_runningkillmemory_info_exmemory_percentniceoneshotparentrlimit send_signalsuspend terminatewait_test_)rQ )ra rb rK rc rd re rf rg rh ri rj rk rl rm rn ro rp rq )setdirpsutilProcess
startswith
assertTruehasattr)r: skipnamer! r! r"
test_coverage s
z$TestProcessObjectLeaks.test_coveragec C s | j | jj d S )N)rR procr| )r: r! r! r" test_name s z TestProcessObjectLeaks.test_namec C s | j | jj d S )N)rR r~ Zcmdline)r: r! r! r" test_cmdline s z#TestProcessObjectLeaks.test_cmdlinec C s | j | jj d S )N)rR r~ Zexe)r: r! r! r" test_exe s z TestProcessObjectLeaks.test_exec C s | j | jj d S )N)rR r~ Zppid)r: r! r! r" test_ppid s z TestProcessObjectLeaks.test_ppidz
POSIX onlyc C s | j | jj d S )N)rR r~ Zuids)r: r! r! r" test_uids s z TestProcessObjectLeaks.test_uidsc C s | j | jj d S )N)rR r~ Zgids)r: r! r! r" test_gids s z TestProcessObjectLeaks.test_gidsc C s | j | jj d S )N)rR r~ Zstatus)r: r! r! r" test_status s z"TestProcessObjectLeaks.test_statusc C s | j | jj d S )N)rR r~ rj )r: r! r! r"
test_nice_get s z$TestProcessObjectLeaks.test_nice_getc C s t j }| j| jj| d S )N)rJ rj rR r~ )r: Znicenessr! r! r"
test_nice_set s z$TestProcessObjectLeaks.test_nice_setz
not supportedc C s | j | jj d S )N)rR r~ re )r: r! r! r" test_ionice_get s z&TestProcessObjectLeaks.test_ionice_getc C sV t r tj }| j| jj| n4| j| jjtj tjt j
t j dd}| j
t| d S )Nr, r )r rJ re rR r~ rv ZIOPRIO_CLASS_NONE functoolspartialcextZproc_ioprio_setosgetpidrU OSError)r: r5 r? r! r! r" test_ionice_set s z&TestProcessObjectLeaks.test_ionice_setc C s | j | jj d S )N)rR r~ Z io_counters)r: r! r! r" test_io_counters s z'TestProcessObjectLeaks.test_io_counterszworthless on POSIXc C s | j | jj d S )N)rR r~ Zusername)r: r! r! r"
test_username s z$TestProcessObjectLeaks.test_usernamec C s | j | jj d S )N)rR r~ Z create_time)r: r! r! r" test_create_time s z'TestProcessObjectLeaks.test_create_time)Zonly_ifc C s | j | jj d S )N)rR r~ Z num_threads)r: r! r! r" test_num_threads s z'TestProcessObjectLeaks.test_num_threadsz WINDOWS onlyc C s | j | jj d S )N)rR r~ Z num_handles)r: r! r! r" test_num_handles s z'TestProcessObjectLeaks.test_num_handlesc C s | j | jj d S )N)rR r~ Znum_fds)r: r! r! r" test_num_fds s z#TestProcessObjectLeaks.test_num_fdsc C s | j | jj d S )N)rR r~ Znum_ctx_switches)r: r! r! r" test_num_ctx_switches! s z,TestProcessObjectLeaks.test_num_ctx_switchesc C s | j | jj d S )N)rR r~ Zthreads)r: r! r! r" test_threads% s z#TestProcessObjectLeaks.test_threadsc C s | j | jj d S )N)rR r~ cpu_times)r: r! r! r" test_cpu_times* s z%TestProcessObjectLeaks.test_cpu_timesc C s | j | jj d S )N)rR r~ Zcpu_num)r: r! r! r" test_cpu_num. s z#TestProcessObjectLeaks.test_cpu_numc C s | j | jj d S )N)rR r~ rW )r: r! r! r" test_memory_info3 s z'TestProcessObjectLeaks.test_memory_infoc C s | j | jj d S )N)rR r~ rV )r: r! r! r" test_memory_full_info7 s z,TestProcessObjectLeaks.test_memory_full_infoc C s | j | jj d S )N)rR r~ Zterminal)r: r! r! r"
test_terminal; s z$TestProcessObjectLeaks.test_terminalz worthless on POSIX (pure python)c C s | j | jj d S )N)rR r~ resume)r: r! r! r" test_resume@ s z"TestProcessObjectLeaks.test_resumec C s | j | jj d S )N)rR r~ cwd)r: r! r! r" test_cwdE s z TestProcessObjectLeaks.test_cwdc C s | j | jj d S )N)rR r~ rc )r: r! r! r" test_cpu_affinity_getI s z,TestProcessObjectLeaks.test_cpu_affinity_getc C s4 t j }| j| jj| ts0| jt| jjdg d S )Nr, r )rJ rc rR r~ r rU
ValueError)r: Zaffinityr! r! r" test_cpu_affinity_setM s z,TestProcessObjectLeaks.test_cpu_affinity_setc C s0 t t ttd | j| jj W d Q R X d S )Nw)r r openrR r~ Z
open_files)r: r! r! r" test_open_filesT s z&TestProcessObjectLeaks.test_open_filesztoo slow on OSXc C s | j | jj d S )N)rR r~ Z memory_maps)r: r! r! r" test_memory_maps[ s z'TestProcessObjectLeaks.test_memory_mapsz
LINUX onlyc C s | j | jjtj d S )N)rR r~ rm rv
RLIMIT_NOFILE)r: r! r! r" test_rlimit_geta s z&TestProcessObjectLeaks.test_rlimit_getc C s6 t jtj}| j| jjtj| | jt| jjd d S )Nr, r )rJ rm rv r rR r~ rU r )r: limitr! r! r" test_rlimit_setf s z&TestProcessObjectLeaks.test_rlimit_setzworthless on WINDOWSc
C s2 t " trdnd}| j| jj| W d Q R X d S )NZinetall)r
r rR r~ Z connections)r: Zkindr! r! r" test_connectionsm s z'TestProcessObjectLeaks.test_connectionsc C s | j | jj d S )N)rR r~ environ)r: r! r! r" test_environy s z#TestProcessObjectLeaks.test_environc C s | j tjtj d S )N)rR r proc_infor r )r: r! r! r" test_proc_info} s z%TestProcessObjectLeaks.test_proc_infoN);rX rY rZ r[ rJ r~ r} r# r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r! r! r! r" r` sh
r` c sp e Zd ZdZe fddZe fddZdd Zerhdd Z d
d Z
d d
Z dd Z dd Z
dd Z ZS )TestTerminatedProcessLeakszRepeat the tests above looking for leaks occurring when dealing
with terminated processes raising NoSuchProcess exception.
The C functions are still invoked but will follow different code
paths. We'll check those code paths.
c s: t t| j t }tj|j| _| jj | jj d S )N)
superr
setUpClassr rv rw ra r~ rg rq )clsp) __class__r! r" r s
z%TestTerminatedProcessLeaks.setUpClassc s t t| j t d S )N)r r
tearDownClassr )r )r r! r" r s z(TestTerminatedProcessLeaks.tearDownClassc O s* y||| W n t jk
r$ Y nX d S )N)rv Z
NoSuchProcess)r: r? r> r@ r! r! r" r< s z TestTerminatedProcessLeaks._callc C s | j | jj d S )N)rR r~ rg )r: r! r! r" test_kill s z$TestTerminatedProcessLeaks.test_killc C s | j | jj d S )N)rR r~ rp )r: r! r! r" test_terminate s z)TestTerminatedProcessLeaks.test_terminatec C s | j | jj d S )N)rR r~ ro )r: r! r! r" test_suspend s z'TestTerminatedProcessLeaks.test_suspendc C s | j | jj d S )N)rR r~ r )r: r! r! r" r s z&TestTerminatedProcessLeaks.test_resumec C s | j | jj d S )N)rR r~ rq )r: r! r! r" test_wait s z$TestTerminatedProcessLeaks.test_waitc s fdd} j | d S )Nc sD yt j jjS tk
r> } z| jtjkr. W Y d d } ~ X nX d S )N)r r r~ ra r errnoZESRCH)err)r: r! r" rT s
z7TestTerminatedProcessLeaks.test_proc_info..call)rR )r: rT r! )r: r" r s z)TestTerminatedProcessLeaks.test_proc_info)rX rY rZ r[ classmethodr r r< r r r r r r r
__classcell__r! r! )r r" r s r c @ s e Zd ZdZdd Ze dd Ze dd Ze dd Ze d
d Z d d
Z
e e j e
ddd Zdd Ze j eddd Ze j eoeddd Ze j eoeddd Zdd Ze j eoejjd d e d d Ze d!d" Z e d#d$ Z e j ed%e j e o&ej d&kd'd(d) Z d*d+ Z!e j e"d,d-d. Z#e e j e$ dd/d0 Z%e e j e& dd1d2 Z'e e j e( dd3d4 Z)e d5d6 Z*e j e+d7d8d9 Z,e+rd:d; Z-dd? Z/d@dA Z0dBdC Z1dDS )ETestModuleFunctionsLeaksz&Test leaks of psutil module functions.c C sH t d
}x:tjD ]0}|j s q||kr(q| jt| d| |d qW d S ) N version_info __version__ process_iter
wait_procsrd cpu_times_percent cpu_countrs )rQ )r r r r rd r r )rt rv __all__islowerry rz )r: r{ r| r! r! r" r} s z&TestModuleFunctionsLeaks.test_coveragec C s | j tjdd d S )NT)logical)rR rv r )r: r! r! r" test_cpu_count_logical s z/TestModuleFunctionsLeaks.test_cpu_count_logicalc C s | j tjdd d S )NF)r )rR rv r )r: r! r! r" test_cpu_count_physical s z0TestModuleFunctionsLeaks.test_cpu_count_physicalc C s | j tj d S )N)rR rv r )r: r! r! r" r s z'TestModuleFunctionsLeaks.test_cpu_timesc C s | j tjdd d S )NT)Zpercpu)rR rv r )r: r! r! r" test_per_cpu_times s z+TestModuleFunctionsLeaks.test_per_cpu_timesc C s | j tj d S )N)rR rv Z cpu_stats)r: r! r! r" test_cpu_stats s z'TestModuleFunctionsLeaks.test_cpu_statsz
not supportedc C s | j tj d S )N)rR rv Zcpu_freq)r: r! r! r"
test_cpu_freq s z&TestModuleFunctionsLeaks.test_cpu_freqc C s | j tj d S )N)rR rv Zvirtual_memory)r: r! r! r" test_virtual_memory s z,TestModuleFunctionsLeaks.test_virtual_memoryz&worthless on SUNOS (uses a subprocess)c C s | j tj d S )N)rR rv Z swap_memory)r: r! r! r" test_swap_memory s z)TestModuleFunctionsLeaks.test_swap_memoryz worthless on POSIX (pure python)c C s | j tjtj d S )N)rR rv Z
pid_existsr r )r: r! r! r" test_pid_exists s z(TestModuleFunctionsLeaks.test_pid_existsc C s | j tjd d S )N.)rR rv Z
disk_usage)r: r! r! r" test_disk_usage s z(TestModuleFunctionsLeaks.test_disk_usagec C s | j tj d S )N)rR rv Zdisk_partitions)r: r! r! r" test_disk_partitions s z-TestModuleFunctionsLeaks.test_disk_partitionsz/proc/diskstatsz3/proc/diskstats not available on this Linux versionc C s | j tjdd d S )NF)nowrap)rR rv Zdisk_io_counters)r: r! r! r" test_disk_io_counters s z.TestModuleFunctionsLeaks.test_disk_io_countersc C s | j tj d S )N)rR rv Zpids)r: r! r! r" test_pids s z"TestModuleFunctionsLeaks.test_pidsc C s | j tjdd d S )NF)r )rR rv Znet_io_counters)r: r! r! r" test_net_io_counters s z-TestModuleFunctionsLeaks.test_net_io_countersz worthless on Linux (pure python)r zneed root accessc C s" t | jtj W d Q R X d S )N)r
rR rv Znet_connections)r: r! r! r" test_net_connections s z-TestModuleFunctionsLeaks.test_net_connectionsc C s | j tjtrdnd d d S )NP i )rC i @ )rR rv Z net_if_addrsr )r: r! r! r" test_net_if_addrs s z*TestModuleFunctionsLeaks.test_net_if_addrszEPERM on travisc C s | j tj d S )N)rR rv Z net_if_stats)r: r! r! r" test_net_if_stats s z*TestModuleFunctionsLeaks.test_net_if_statsc C s | j tj d S )N)rR rv Zsensors_battery)r: r! r! r" test_sensors_battery$ s z-TestModuleFunctionsLeaks.test_sensors_batteryc C s | j tj d S )N)rR rv Zsensors_temperatures)r: r! r! r" test_sensors_temperatures) s z2TestModuleFunctionsLeaks.test_sensors_temperaturesc C s | j tj d S )N)rR rv Z sensors_fans)r: r! r! r" test_sensors_fans. s z*TestModuleFunctionsLeaks.test_sensors_fansc C s | j tj d S )N)rR rv Z boot_time)r: r! r! r" test_boot_time5 s z'TestModuleFunctionsLeaks.test_boot_timez(XXX produces a false positive on Windowsc C s | j tj d S )N)rR rv Zusers)r: r! r! r"
test_users: s z#TestModuleFunctionsLeaks.test_usersc C s | j tj d S )N)rR r Zwinservice_enumerate)r: r! r! r" test_win_service_iterB s z.TestModuleFunctionsLeaks.test_win_service_iterc C s d S )Nr! )r: r! r! r" test_win_service_getE s z-TestModuleFunctionsLeaks.test_win_service_getc C s" t tj j }| jtj| d S )N)nextrv win_service_iterr| rR r Zwinservice_query_config)r: r| r! r! r" test_win_service_get_configH s z4TestModuleFunctionsLeaks.test_win_service_get_configc C s" t tj j }| jtj| d S )N)r rv r r| rR r Zwinservice_query_status)r: r| r! r! r" test_win_service_get_statusL s z4TestModuleFunctionsLeaks.test_win_service_get_statusc C s" t tj j }| jtj| d S )N)r rv r r| rR r Zwinservice_query_descr)r: r| r! r! r" test_win_service_get_descriptionP s z9TestModuleFunctionsLeaks.test_win_service_get_descriptionN)2rX rY rZ r[ r} r# r r r r r r r r
r r r r r r r r r r r pathexistsr r r r getuidr r r r r r r r r r r r r r r r r r r! r! r! r" r sR
$r __main__):r[ Z
__future__r r r r8 r rO rI rM rv Zpsutil._commonr r r r r r Zpsutil._compatr Z psutil.testsr
r r r
r r r r r r r r r r r r r r r r r] r\ r^ r Z _psplatformr rw rJ r# r6 ZTestCaser7 r` r r rX __file__r! r! r! r"
sl c B<
PK ! )3 3 % __pycache__/test_posix.cpython-36.pycnu [ 3
JZ? @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddlm Z ddlm
Z
ddlm Z ddlm Z ddlm
Z
ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! dd Z"d d Z#d d Z$e j%e d G d!d" d"e j&Z'e j%e d G d#d$ d$e j&Z(e)d%kree* dS )&zPOSIX specific tests. N)AIX)BSD)LINUX)OPENBSD)OSX)POSIX)SUNOS)callable)PY3)APPVEYOR)get_kernel_version)get_test_subprocess)mock)
PYTHON_EXE)
reap_children)retry_before_failing)run_test_module_by_name)sh)skip_on_access_denied)TRAVIS)unittest) wait_for_pid)whichc C sp t s| jdd} tr | jdd} tr0| jdd} t| }t sN|jdd j }yt|S tk
rj |S X d S )
zkExpects a ps command with a -o argument and parse the result
returning only the value of interest.
z --no-headers z-o startz-o stimez-o rssz -o rssize
N) r replacer r r splitstripint
ValueError)cmdoutput r# "/usr/lib64/python3.6/test_posix.pyps+ s r% c C s& d}t r d}td|| f jdd S )NcommandZcommzps --no-headers -o %s -p %sr r )r r% r )pidfieldr# r# r$ ps_nameI s r) c C s d}t s trd}td|| f S )Nr& argszps --no-headers -o %s -p %s)r r r% )r' r( r# r# r$ ps_argsP s r+ z
POSIX onlyc @ s e Zd ZdZedd Zedd Zdd Zdd Zd
d Z d d
Z
dd Z e e
dd Ze e
dd Zdd Zdd Zdd Zdd Zejeped d d Zd d Zd!d" Zejed#eje d$d%d& Z d'd( Z d)S )* TestProcesszBCompare psutil results against 'ps' command line utility (mainly).c C s& t tddgtjdj| _t| j d S )Nz-Ez-O)stdin)r
r
subprocessPIPEr' r )clsr# r# r$
setUpClass[ s
zTestProcess.setUpClassc C s
t d S )N)r )r0 r# r# r$
tearDownClassa s zTestProcess.tearDownClassc C s. t d| j }tj| jj }| j|| d S )Nz ps --no-headers -o ppid -p %s)r% r' psutilProcessZppid assertEqual)selfZppid_psZ ppid_psutilr# r# r$ test_ppide s zTestProcess.test_ppidc C s0 t d| j }tj| jj j}| j|| d S )Nz ps --no-headers -o uid -p %s)r% r' r3 r4 uidsrealr5 )r6 Zuid_psZ
uid_psutilr# r# r$ test_uidj s zTestProcess.test_uidc C s0 t d| j }tj| jj j}| j|| d S )Nz ps --no-headers -o rgid -p %s)r% r' r3 r4 Zgidsr9 r5 )r6 Zgid_psZ
gid_psutilr# r# r$ test_gido s zTestProcess.test_gidc C s. t d| j }tj| jj }| j|| d S )Nz ps --no-headers -o user -p %s)r% r' r3 r4 usernamer5 )r6 Z username_psZusername_psutilr# r# r$
test_usernamet s zTestProcess.test_usernamec C sJ t j }tjdtd*}| j|j t|j j |j
s )r r? r3 AccessDeniedr4 r5 rP )r6 rP rD r# r# r$ test_name_long_cmdline_ad_exc s
z)TestProcess.test_name_long_cmdline_ad_excc C s\ d}t jd|d@ t jdtjddd tj }| jtj|j W d Q R X W d Q R X d S )Nzlong-program-namez psutil._psplatform.Process.name)rT z"psutil._psplatform.Process.cmdliner rK )r> )r r? r3 Z
NoSuchProcessr4 assertRaisesrP )r6 rP rD r# r# r$ test_name_long_cmdline_nsp_exc s
z*TestProcess.test_name_long_cmdline_nsp_exczps -o start not availablec C sh t d| j jdd }tj| jj }tjj|jd}t |}tjj|jd}| j
|||g d S )Nz ps --no-headers -o start -p %sr r z%H:%M:%S) r% r' r r3 r4 Z create_timedatetimeZ
fromtimestampZstrftimeroundassertIn)r6 Ztime_psZ time_psutilZtime_psutil_tstampZround_time_psutilZround_time_psutil_tstampr# r# r$ test_create_time s z TestProcess.test_create_timec C s` t | j}tj| jj }y| j|| W n0 tk
rZ |d t| }| j|| Y nX d S )N)r) r' r3 r4 Zexer5 rC len)r6 Z ps_pathnameZpsutil_pathnameZadjusted_ps_pathnamer# r# r$ test_exe s
zTestProcess.test_exec C s0 t | j}djtj| jj }| j|| d S )Nr )r+ r' joinr3 r4 rU r5 )r6 Z
ps_cmdlineZpsutil_cmdliner# r# r$ test_cmdline s
zTestProcess.test_cmdlineznot reliable on SUNOSznot reliable on AIXc C s* t d| j }tj j }| j|| d S )Nz ps --no-headers -o nice -p %s)r% r' r3 r4 nicer5 )r6 Zps_niceZ psutil_nicer# r# r$ test_nice s zTestProcess.test_nicec
s fdd}t jtj }g }ddddddd d
d d g
}trNt dk rN|jd trft dk rf|jd xtt jD ] jdsr |krqrqry0|j }xt
d
D ]}|| qW |j }W n t j k
r Y qrX t || dkrrd ||f }|j| qrW |r| j
ddj| d S )Nc sB f }t | d }|d k r:t|r: dkr0tjf}|| n| d S )Nrlimit)getattrr r3 Z
RLIMIT_NOFILE)rD attrr* )rP r# r$ call s
z&TestProcess.test_num_fds..callZ terminatekillZsuspendZresumerc Z send_signalwaitZchildrenZas_dictZmemory_info_ex $ re Znum_ctx_switches_r z@failure while processing Process.%s method (before=%s, after=%s)r )rk rl rm )rk rl rn )r3 r4 rL getpidr r appenddir
startswithZnum_fdsrangerW absfailra ) r6 rh rD ZfailuresZ
ignored_namesZnum1xZnum2rv r# )rP r$ test_num_fds s4
zTestProcess.test_num_fdsN) __name__
__module__ __qualname____doc__ classmethodr1 r2 r7 r: r; r= rE r r rI rJ rS rV rX rZ r skipIfr r r^ r` rb r r rd rx r# r# r# r$ r, W s,
r, c @ s e Zd ZdZe dd Zejedeje deje
d ddd Z eje p`e o`e
j d
e d d Zd
d Zdd Zdd Zdd Zejeddd ZdS )TestSystemAPIszTest some system APIs.c C s t strddddg}n ddddg}t|tjd}|j d j }|j dksPtt rbt
|t j j
}g }x<|jdd d D ]&}|rzt|j d j }|j| qzW |j|j tj }|j |j tstrd|kr|jdd | j|| d S )
Nr% z-Az-or' Zax)stdoutr r r )r r r
r. r/ Z communicater ZpollrC r
rA sysr encodingr r rq remover' r3 Zpidssortr r insertr5 )r6 r! rD r" Zpids_psliner' Z pids_psutilr# r# r$ test_pids s( zTestSystemAPIs.test_pidszunreliable on SUNOSzunreliable on TRAVISZifconfigzno ifconfig cmdc C sV t d}xHtjddj D ]4}x.|j D ]}|j|r(P q(W | jd||f qW d S )Nz ifconfig -aT)Zpernicz/couldn't find %s nic in 'ifconfig -a' output
%s)r r3 Znet_io_counterskeysr rs rv )r6 r" Znicr r# r# r$ test_nic_names? s
z TestSystemAPIs.test_nic_namesz unreliable on APPVEYOR or TRAVISc C sx t d}|jd}dd |D }dd |D }| jt|ttj x,tj D ] }| j|j| | j|j| qPW d S )NZwhor c S s g | ]}|j d qS )r )r ).0rw r# r# r$
T s z-TestSystemAPIs.test_users..c S s g | ]}|j d qS )r )r )r rw r# r# r$ r U s ) r r r5 r_ r3 usersr] rP Zterminal)r6 outlinesr Z terminalsur# r# r$
test_usersN s
zTestSystemAPIs.test_usersc C sF t jdttjdd&}| jttjjt j
|j s8t W d Q R X d S )Nzpsutil._psposix.os.killrK )r> )
r r? OSErrorerrnoEBADFrY r3 _psposixZ
pid_existsrL rp rB rC )r6 mr# r# r$ test_pid_exists_let_raise[ s z(TestSystemAPIs.test_pid_exists_let_raisec C sF t jdttjdd&}| jttjjt j
|j s8t W d Q R X d S )Nzpsutil._psposix.os.waitpidrK )r> )
r r? r r r rY r3 r wait_pidrL rp rB rC )r6 r r# r# r$ test_os_waitpid_let_raised s z(TestSystemAPIs.test_os_waitpid_let_raisec
C sN t jdttjdd.}| jtjjtjj t
j dd |j s@t
W d Q R X d S )Nzpsutil._psposix.os.waitpidrK )r> g{Gz?)Ztimeout)r r? r r ZEINTRrY r3 r ZTimeoutExpiredr rL rp rB rC )r6 r r# r# r$ test_os_waitpid_eintrl s z$TestSystemAPIs.test_os_waitpid_eintrc C s> t jddd&}| jttjjtj |j s0t
W d Q R X d S )Nzpsutil._psposix.os.waitpidr )rT )r r ) r r? rY r r3 r r rL rp rB rC )r6 r r# r# r$ test_os_waitpid_bad_ret_statusu s
z-TestSystemAPIs.test_os_waitpid_bad_ret_statuszunreliable on AIXc
C s dd }d
}xt jddD ]}t j|j}y||j\}}}}W nL tk
r } z0t| j } d| ksvd| ksvd | krzwn W Y d d } ~ X qX | j|j ||d
| j|j
||d
| j|j ||d
| j|j |d d
qW d S )Nc S sv t d| j }|jdd }|j }t|d d }t|d d }t|d d }t|d jdd }||||fS )
Nzdf -k %sr r i rk %rK )r r r r floatr )devicer r Zfieldstotalusedfreepercentr# r# r$ df s z*TestSystemAPIs.test_disk_usage..dfr i F)allzno such file or directoryzraw devices not supportedzpermission denied)Zdeltar i i @ )
r3 Zdisk_partitionsZ
disk_usageZ
mountpointr RuntimeErrorrA rO ZassertAlmostEqualr r r r )
r6 r Z tolerancepartZusager r r r errr# r# r$ test_disk_usage~ s"
z TestSystemAPIs.test_disk_usageN)ry rz r{ r| r r r r~ r r r r r r3 r r r r r r r r r# r# r# r$ r s
r __main__)+r| r[ r rL rQ r. r rF r3 r r r r r r r Zpsutil._compatr r
Z psutil.testsr r r
r r r r r r r r r r r r% r) r+ r~ ZTestCaser, r ry __file__r# r# r# r$ sT
E
PK ! P([ [ ) __pycache__/test_contracts.cpython-36.pycnu [ 3
JZ2^ @ s d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
ddl m Z ddl m Z ddl m
Z
ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
l mZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# dd lm$Z$ dd lm%Z% dd lm&Z& dd lm'Z' ddl Z G d d! d!e$j(Z)G d"d# d#e$j(Z*G d$d% d%e$j(Z+G d&d' d'e$j(Z,e-d(kre e. dS ))zContracts tests. These tests mainly check API sanity in terms of
returned types and APIs availability.
Some of these are duplicates of tests test_system.py and test_process.py
N)closing)AIX)BSD)FREEBSD)LINUX)NETBSD)OPENBSD)OSX)POSIX)SUNOS)WINDOWS)callable)long)bind_unix_socket)check_connection_ntuple)get_kernel_version)HAS_CONNECTIONS_UNIX)
HAS_RLIMIT)HAS_SENSORS_FANS)HAS_SENSORS_TEMPERATURES)
is_namedtuple)run_test_module_by_name) safe_rmpath)skip_on_access_denied)TESTFN)unittest)unix_socket_path)VALID_PROC_STATUSES)warnc @ s e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.S )/TestAvailabilityzQMake sure code reflects what doc promises in terms of APIs
availability.
c C s$ t p
tp
t}| jttjd| d S )N cpu_affinity)r r r assertEqualhasattrpsutilProcess)selfhasit r' &/usr/lib64/python3.6/test_contracts.pytest_cpu_affinity< s z"TestAvailability.test_cpu_affinityc C s( | j ttdt | j ttdt d S )NZwin_service_iterZwin_service_get)r! r" r# r )r% r' r' r( test_win_service@ s z!TestAvailability.test_win_servicec C s | j ttdtptpt d S )NZ PROCFS_PATH)r! r" r# r r r )r% r' r' r( test_PROCFS_PATHD s z!TestAvailability.test_PROCFS_PATHc C sj | j }|ttdt |ttdt |ttdt |ttdt |ttdt |ttdt d S )NZABOVE_NORMAL_PRIORITY_CLASSZBELOW_NORMAL_PRIORITY_CLASSZHIGH_PRIORITY_CLASSZIDLE_PRIORITY_CLASSZNORMAL_PRIORITY_CLASSZREALTIME_PRIORITY_CLASS)r! r" r# r )r% aer' r' r( test_win_priorityH s z"TestAvailability.test_win_priorityc C sJ | j }|ttdt |ttdt |ttdt |ttdt d S )NZIOPRIO_CLASS_NONEZIOPRIO_CLASS_RTZIOPRIO_CLASS_BEZIOPRIO_CLASS_IDLE)r! r" r# r )r% r, r' r' r( test_linux_ioprioQ s
z"TestAvailability.test_linux_ioprioc C sH | j }tot dk}|ttjd| |ttd| |ttd| |ttd| |ttd| |ttd | |ttd
| |ttd | |ttd | |ttd
| |ttd| |ttd| |ttd| tot dk}|ttd| |ttd| |ttd| |ttd| |ttd| d S )N $ rlimitZ
RLIM_INFINITYZ RLIMIT_ASZ RLIMIT_COREZ
RLIMIT_CPUZ RLIMIT_DATAZ RLIMIT_FSIZEZ RLIMIT_LOCKSZRLIMIT_MEMLOCK
RLIMIT_NOFILEZ RLIMIT_NPROCZ
RLIMIT_RSSZ RLIMIT_STACK r ZRLIMIT_MSGQUEUEZ RLIMIT_NICEZ
RLIMIT_RTPRIOZ
RLIMIT_RTTIMEZRLIMIT_SIGPENDING)r/ r0 r1 )r4 r )r! r r r" r# r$ )r% r, r& r' r' r( test_linux_rlimitX s* z"TestAvailability.test_linux_rlimitc C s: t otjjdptjjd}| jttd|p2tp2t d S )Nz /sys/devices/system/cpu/cpufreqz$/sys/devices/system/cpu/cpu0/cpufreqZcpu_freq) r ospathexistsr! r" r# r r )r% linuxr' r' r(
test_cpu_freqp s z TestAvailability.test_cpu_freqc C s | j ttdt d S )Nsensors_temperatures)r! r" r# r )r% r' r' r( test_sensors_temperaturesv s z*TestAvailability.test_sensors_temperaturesc C s | j ttdt d S )N sensors_fans)r! r" r# r )r% r' r' r( test_sensors_fansy s z"TestAvailability.test_sensors_fansc C s" | j ttdtptptpt d S )NZsensors_battery)r! r" r# r r r r )r% r' r' r( test_battery| s z TestAvailability.test_batteryc C s | j ttjdtptpt d S )Nenviron)r! r" r# r$ r r r )r% r' r' r( test_proc_environ s z"TestAvailability.test_proc_environc C s | j ttjdt d S )Nuids)r! r" r# r$ r
)r% r' r' r( test_proc_uids s z TestAvailability.test_proc_uidsc C s | j ttjdt d S )NrB )r! r" r# r$ r
)r% r' r' r( test_proc_gids s z TestAvailability.test_proc_gidsc C s | j ttjdt d S )Nterminal)r! r" r# r$ r
)r% r' r' r( test_proc_terminal s z#TestAvailability.test_proc_terminalc C s | j ttjdtpt d S )Nionice)r! r" r# r$ r r )r% r' r' r( test_proc_ionice s z!TestAvailability.test_proc_ionicec C s | j ttjdt d S )Nr2 )r! r" r# r$ r )r% r' r' r( test_proc_rlimit s z!TestAvailability.test_proc_rlimitc C s( t tjd}| j|tstr dnd d S )N io_countersFT)r" r# r$ r! r r )r% r& r' r' r( test_proc_io_counters s z&TestAvailability.test_proc_io_countersc C s | j ttjdt d S )Nnum_fds)r! r" r# r$ r
)r% r' r' r( test_proc_num_fds s z"TestAvailability.test_proc_num_fdsc C s | j ttjdt d S )N num_handles)r! r" r# r$ r )r% r' r' r( test_proc_num_handles s z&TestAvailability.test_proc_num_handlesc C s | j ttjdtptpt d S )Nr )r! r" r# r$ r r r )r% r' r' r( test_proc_cpu_affinity s z'TestAvailability.test_proc_cpu_affinityc C s | j ttjdtptpt d S )Ncpu_num)r! r" r# r$ r r r )r% r' r' r( test_proc_cpu_num s z"TestAvailability.test_proc_cpu_numc C s, t tjd}| j|ts ts tr"dnd d S )N memory_mapsFT)r" r# r$ r! r r r )r% r& r' r' r( test_proc_memory_maps s z&TestAvailability.test_proc_memory_mapsN)__name__
__module__ __qualname____doc__r) r* r+ r- r. r5 r: r< r> r? rA rC rD rF rH rI rK rM rO rP rR rT r' r' r' r( r 7 s. r c @ s e Zd Zdd ZdS )TestDeprecationsc C sd t jdd}tj j W d Q R X |d }| j|j t | jdt |j
| jdt |j
d S )NT)recordr z memory_info_ex() is deprecatedzuse memory_info() instead) warningscatch_warningsr# r$ memory_info_exassertIsInstancecategory
FutureWarningassertInstrmessage)r% Zwswr' r' r( test_memory_info_ex s z$TestDeprecations.test_memory_info_exN)rU rV rW re r' r' r' r( rY s rY c @ s e Zd ZdZedd Zdd Zdd Zdd Zd
d Z e
j e d e
j e
d
eeddd Zdd Zdd Zdd Ze
j e ddd Ze
j e ddd Zd d Zd S )
TestSystemzCheck the return types of system related APIs.
Mainly we want to test we never return unicode on Python 2, see:
https://github.com/giampaolo/psutil/issues/1039
c C s t j | _d S )N)r# r$ proc)clsr' r' r(
setUpClass s zTestSystem.setUpClassc C s t t d S )N)r r )r% r' r' r( tearDown s zTestSystem.tearDownc C s> t j }t|stx$|D ] }| j|t | j|d qW d S )Nr )r# cpu_timesr AssertionErrorr^ floatassertGreaterEqual)r% retnr' r' r( test_cpu_times s
zTestSystem.test_cpu_timesc C s& x t jddD ]}| j|t qW d S )NT)Zperdisk)r# Zdisk_io_countersr^ rb )r% kr' r' r( test_io_counters s zTestSystem.test_io_countersc C sN xHt j D ]<}| j|jt | j|jt | j|jt | j|jt q
W d S )N)r# Zdisk_partitionsr^ Zdevicerb Z
mountpointZfstypeZopts)r% Zdiskr' r' r( test_disk_partitions s
z TestSystem.test_disk_partitionsz
POSIX onlyzcan't list UNIX sockets)Zonly_ifc C s^ t N}tt|6 tjdd}|s*tx|D ]}| j|jt q0W W d Q R X W d Q R X d S )NZunix)Zkind) r r r r# Znet_connectionsrl r^ Zladdrrb )r% nameZconsconnr' r' r( test_net_connections s
z TestSystem.test_net_connectionsc C sr xlt j j D ]\\}}| j|t xF|D ]>}| j|jt | j|jttd f | j|jttd f q(W qW d S )N) r# Z net_if_addrsitemsr^ rb ZaddressZnetmasktypeZ broadcast)r% ifnameZaddrsaddrr' r' r( test_net_if_addrs s
z TestSystem.test_net_if_addrsc C s* x$t j j D ]\}}| j|t qW d S )N)r# Z net_if_statsrx r^ rb )r% rz _r' r' r( test_net_if_stats s z TestSystem.test_net_if_statsc C s. x(t jddj D ]\}}| j|t qW d S )NT)Zpernic)r# Znet_io_countersrx r^ rb )r% rz r} r' r' r( test_net_io_counters s z TestSystem.test_net_io_countersz
not supportedc C sF x@t j j D ]0\}}| j|t x|D ]}| j|jt q(W qW d S )N)r# r= rx r^ rb label)r% ru unitsunitr' r' r( r> s
z TestSystem.test_sensors_fansc C sF x@t j j D ]0\}}| j|t x|D ]}| j|jt q(W qW d S )N)r# r; rx r^ rb r )r% ru r r r' r' r( r< s
z$TestSystem.test_sensors_temperaturesc C sf x`t j D ]T}| j|jt | j|jttd f | j|jttd f | j|jt td f q
W d S )N)
r# usersr^ ru rb rE ry hostpidint)r% userr' r' r(
test_users s
zTestSystem.test_usersN)rU rV rW rX classmethodri rj rq rs rt r ZskipIfr
r r r rw r| r~ r r r> r r< r r' r' r' r( rf s rf c @ s( e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.d/ Zd0d1 Zd2d3 Z d4d5 Z d6d7 Z d8d9 Z d:d; Z dd? Z"d@dA Z#dBdC Z$dDdE Z%dFdG Z&dHS )ITestFetchAllProcessesz~Test which iterates over all running processes and performs
some sanity checks against Process API's returned values.
c C sd t r`dd l}dd l}|j }|j }tdd |D | _tdd |D | _tdd |D | _d S )Nr c S s g | ]
}|j qS r' )Zpw_uid).0xr' r' r(
( s z/TestFetchAllProcesses.setUp..c S s g | ]
}|j qS r' )Zpw_name)r r r' r' r( r ) s c S s g | ]
}|j qS r' )Zgr_gid)r r r' r' r( r * s ) r
pwdgrpZgetpwallZgetgrallsetall_uids
all_usernamesall_gids)r% r r r groupsr' r' r( setUp" s zTestFetchAllProcesses.setUpc C s d}t dddddddd d
d d g }tr6t r6|jd
g }x2ttjD ]$}|jdrVqF||kr`qF|j| qFW t }g }x(tj
D ]}|j x|D ]}|}ydf } i }
t ||d } | d k rt
| r|d
krtjf} n|dkrddi}
| | |
}n| }|d7 }W nL tk
r> d| jjd | } t| Y q tjtjfk
r }
zJ| j|
j|j |
jr| j|
j|j t|
st|
jstW Y d d }
~
X q tk
rX }
zddd d }|d||f 7 }||kr|dt | 7 }|d7 }|dd 7 }|d t j 7 }dj d d |j D }|d7 }|j| P W Y d d }
~
X qX |dd g d d i fkr~|s~t|t | |}||| qW W d Q R X qW |r| j!d j | |std S )!Nr Z send_signalZsuspendZresumeZ terminatekillwaitZas_dictparentZchildrenr] oneshotr2 r} rS ZgroupedF z&%r was skipped because not implementedz.test_
=F zFAIL: test_%s (proc=%sz , ret=%s)z)
-z
%sc s s | ]}d| V qdS ) Nz r' )r ir' r' r( c s z7TestFetchAllProcesses.test_fetch_all..g )"r r r adddirr# r$
startswithappendobjectZ process_iterr getattrr
r3 NotImplementedError __class__rU r Z
NoSuchProcessZ AccessDeniedr! r ru rb rl msg Exceptionrepr traceback
format_excjoin
splitlinesZfail)r% Z valid_procsZexcluded_namesZattrsru defaultZfailurespro argskwargsattrr errsmethr' r' r( test_fetch_all, sx
z$TestFetchAllProcesses.test_fetch_allc C s* | j |t x|D ]}| j |t qW d S )N)r^ listrb )r% ro rg partr' r' r( cmdlinet s
z TestFetchAllProcesses.cmdlinec C st | j |ttd f |s&| j|d nJtjj|s:t|trptjj |rpt
tdrpt
tdrptj |tj sptd S )Nr accessX_OK)
r^ rb ry r! r6 r7 isabsrl r
isfiler" r r )r% ro rg r' r' r( exey s zTestFetchAllProcesses.exec C s | j |t | j|d d S )Nr )r^ r rn )r% ro rg r' r' r( r s zTestFetchAllProcesses.pidc C s | j |ttf | j|d d S )Nr )r^ r r rn )r% ro rg r' r' r( ppid s zTestFetchAllProcesses.ppidc C s | j |t ts|std S )N)r^ rb r rl )r% ro rg r' r' r( ru s zTestFetchAllProcesses.namec C s^ | j |t y| j|d W n* tk
rF tr@|j tjkr@n Y nX tj dtj
| d S )Nr z%Y %m %d %H:%M:%S) r^ rm rn rl r statusr# Z
STATUS_ZOMBIEtimeZstrftimeZ localtime)r% ro rg r' r' r( create_time s z!TestFetchAllProcesses.create_timec C sD t |s tx2|D ]*}| j|t | j|d | j|| j qW d S )Nr )r rl r^ r rn ra r )r% ro rg Zuidr' r' r( rB s
zTestFetchAllProcesses.uidsc C sP t |s tx>|D ]6}| j|t t rt r| j|d | j|| j qW d S )Nr ) r rl r^ r r r rn ra r )r% ro rg gidr' r' r( gids s
zTestFetchAllProcesses.gidsc C s* | j |t |sttr&| j|| j d S )N)r^ rb rl r
ra r )r% ro rg r' r' r( username s z TestFetchAllProcesses.usernamec C s0 | j |t |st| j|d | j|t d S )N?)r^ rb rl ZassertNotEqualra r )r% ro rg r' r' r( r s z TestFetchAllProcesses.statusc C sB t |s tx0|D ](}| j|ttf |dkr| j|d qW d S )Nr r )r rl r^ r r rn )r% ro rg fieldr' r' r( rJ s
z!TestFetchAllProcesses.io_countersc C sh t r*t|stx|D ]}| j|t qW trL| j|jd | j|jd n| j|d | j |d d S )Nr r r/ )r r r/ )
r
r rl r^ r r rn Zioclassvaluera )r% ro rg r r' r' r( rG s
z TestFetchAllProcesses.ionicec C s | j |t | j|d d S )Nr )r^ r rn )r% ro rg r' r' r( num_threads s z!TestFetchAllProcesses.num_threadsc C sr | j |t x`|D ]X}t|s"t| j|jd | j|jd | j|jd x |D ]}| j |tt f qRW qW d S )Nr )
r^ r r rl rn idZ user_timeZ system_timer rm )r% ro rg tr r' r' r( threads s
z TestFetchAllProcesses.threadsc C s6 t |s tx$|D ] }| j|t | j|d qW d S )Nr )r rl r^ rm rn )r% ro rg rp r' r' r( rk s
z TestFetchAllProcesses.cpu_timesc C s0 | j |t d| ko dkn s,t|d S )Ng g Y@)r^ rm rl )r% ro rg r' r' r( cpu_percent s z!TestFetchAllProcesses.cpu_percentc C s\ | j |t tr |dkr d S | j|d tj dkr@| j|d | j|tt tj d S )Nr r r )
r^ r r rn r# cpu_countr! ra r range)r% ro rg r' r' r( rQ s z TestFetchAllProcesses.cpu_numc C s t |s tx(|D ] }| j|ttf | j|d qW trt r|jdkrxx|j D ](}|dkrRt
||}| j |j||d qRW nDt r| j|j
|j | j|j|j | j|j|j | j|j|j d S )Nr vms)r )r rl r^ r r rn r
r r _fieldsr
assertGreaterr Z peak_wsetZwsetZpeak_paged_poolZ
paged_poolZpeak_nonpaged_poolZ
nonpaged_poolZ
peak_pagefileZpagefile)r% ro rg r ru r' r' r( memory_info s
z!TestFetchAllProcesses.memory_infoc C s t |s ttj j}xR|jD ]H}t||}| j|tt f | j
|d||fd | j |||||fd q W t r~| j
|j
|j d S )Nr )r )r rl r# Zvirtual_memorytotalr r r^ r r rn ZassertLessEqualr ZpssZuss)r% ro rg r ru r r' r' r( memory_full_info s
z&TestFetchAllProcesses.memory_full_infoc C s | j |t x|D ]}| j |jt | j |jt trF| j|jd nhtr| j |j t | j |j
t | j |j t | j |j d | j
|j
d | j|j d ntr|j rqtjj|jst|tjj|jst|qW d S )
Nr r rrd ar+a+r )r rd r r r )r^ r fdr r7 rb r r! r Zpositionmodeflagsrn ra r r r6 r rl r )r% ro rg fr' r' r(
open_files s"
z TestFetchAllProcesses.open_filesc C s | j |t | j|d d S )Nr )r^ r rn )r% ro rg r' r' r( rL ( s z TestFetchAllProcesses.num_fdsc C s2 | j t|tt| x|D ] }t| q W d S )N)r! lenr r )r% ro rg rv r' r' r( connections, s
z!TestFetchAllProcesses.connectionsc C s |r| j |t tjj|s$t|ytj|}W nD tk
rv } z(trX|j t
j j krXn|j t j
krf W Y d d }~X nX tj|jstd S )N)r^ rb r6 r7 r rl statOSErrorr errnor# Z _psplatformZACCESS_DENIED_SETENOENTS_ISDIRst_mode)r% ro rg str r' r' r( cwd1 s
zTestFetchAllProcesses.cwdc C s0 | j |t d| ko dkn s,t|d S )Nr d )r^ rm rl )r% ro rg r' r' r( memory_percentA s z$TestFetchAllProcesses.memory_percentc C s | j |t d S )N)r^ bool)r% ro rg r' r' r(
is_runningE s z TestFetchAllProcesses.is_runningc C sR | j |t |g ks t|ttj }x$|D ] }| j |t | j|| q.W d S )N)r^ r rl r r# r r ra )r% ro rg Zcpusrp r' r' r( r H s
z"TestFetchAllProcesses.cpu_affinityc C sH | j |ttd f |d k rDtjj|s0t|tjj|sDt|d S )N)r^ rb ry r6 r7 r rl r8 )r% ro rg r' r' r( rE P s z TestFetchAllProcesses.terminalc C s x|D ]}| j |jt | j |jt | j |jt xr|jD ]h}t||}|dkrv|jdstjj |jst
|jq<|dkr|st
q<| j |t t f | j
|d q.i)r^ r r
rl r r# ra )r% ro rg Z
prioritiesr' r' r( nicem s
"zTestFetchAllProcesses.nicec C s: t |s tx(|D ] }| j|ttf | j|d qW d S )Nr )r rl r^ r r rn )r% ro rg r r' r' r( num_ctx_switchesv s
z&TestFetchAllProcesses.num_ctx_switchesc C s@ | j |t | jt|d | j|d d | j|d d d S )Nr/ r r r r )r^ tupler! r rn )r% ro rg r' r' r( r2 | s z TestFetchAllProcesses.rlimitc C s> | j |t x,|j D ] \}}| j |t | j |t qW d S )N)r^ dictrx rb )r% ro rg rr vr' r' r( r@ s z TestFetchAllProcesses.environN)'rU rV rW rX r r r r r r ru r rB r r r rJ rG r r rk r rQ r r r rL r r r r r rE rS rN r r r2 r@ r' r' r' r( r sH
H
r __main__)/rX r r6 r r r r[
contextlibr r# r r r r r r r r
r r Zpsutil._compatr
r Z psutil.testsr r r r r r r r r r r r r r r r ZTestCaser rY rf r rU __file__r' r' r' r( sX x^ n
PK ! t_8 8 1 __pycache__/test_connections.cpython-36.opt-1.pycnu [ 3
JZP @ s8 d Z ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddl
Z
ddl
m Z dd l
m Z dd
l
m
Z
dd l
mZ dd l
mZ dd
l
mZ ddl
mZ ddl
mZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! dd lm"Z" dd lm#Z# dd lm$Z$ dd lm%Z% dd lm&Z& dd!lm'Z' dd"lm(Z( dd#lm)Z) dd$lm*Z* e
j+ Z,G d%d& d&e-Z.G d'd( d(e.e'j/Z0G d)d* d*e.e'j/Z1G d+d, d,e.e'j/Z2G d-d. d.e'j/Z3e4d/kr4e!e5 dS )0z;Tests for net_connections() and Process.connections() APIs. N)closing)AF_INET)AF_INET6)
SOCK_DGRAM) SOCK_STREAM)FREEBSD)LINUX)NETBSD)OPENBSD)OSX)POSIX)SUNOS)WINDOWS)
supports_ipv6)PY3)AF_UNIX) bind_socket)bind_unix_socket)check_connection_ntuple)create_sockets)
get_free_port)HAS_CONNECTIONS_UNIX)pyrun)
reap_children)run_test_module_by_name) safe_rmpath)skip_on_access_denied)tcp_socketpair)TESTFN)TRAVIS)unittest)unix_socket_path)unix_socketpair)
wait_for_filec @ s8 e Zd Zdd Zdd Zdd Zd
dd Zdd d ZdS )Basec C s t stjdd}d S )Nall)kind)r thisproc connections)selfcons r+ (/usr/lib64/python3.6/test_connections.pysetUp6 s z
Base.setUpc C s" t t t ts tjdd}d S )Nr% )r& )r r r r r' r( )r) r* r+ r+ r, tearDown< s
z
Base.tearDownc C sr t jdd}tdd |D }tr.||j S | jt|d |d jdkrf| j||j j|j |d S d S )Nr% )r& c S s g | ]}|j |fqS r+ )fd).0cr+ r+ r,
G s z+Base.get_conn_from_sock.. r )r' r( dictr fileno assertEquallenr/ )r) sockr* Zsmapr+ r+ r, get_conn_from_sockE s zBase.get_conn_from_sockNc C s |dkr| j |}t| |jdkr6| j|j|j | j|j|j | j|j|jtj tj
|j }| rt rt
|tr|j }|jtkr|dd }|jtkrtrn| j|j| |jtkrtrtjdd}| jtj | |S )zGiven a socket, makes sure it matches the one obtained
via psutil. It assumes this process created one connection
only (the one supposed to be checked).
Nr3 r% )r& r4 )r: r r/ r7 r6 familytypeZ
getsockoptsocketZ
SOL_SOCKETZSO_TYPEZ getsocknamer
isinstancebytesdecoder r r
laddrr r' r( compare_procsys_connectionsosgetpid)r) r9 connrB r* r+ r+ r, check_socketR s(
zBase.check_socketr% c sd yt j|d}W n t jk
r0 tr*dS Y nX fdd|D }|j |j | j|| dS )zGiven a process PID and its list of connections compare
those against system-wide connections retrieved via
psutil.net_connections.
)r& Nc s" g | ]}|j kr|d d qS )Nr3 r4 )pid)r0 r1 )rH r+ r, r2 s z4Base.compare_procsys_connections..)psutilnet_connectionsZ AccessDeniedr sortr7 )r) rH Z proc_consr& Zsys_consr+ )rH r, rC v s z Base.compare_procsys_connections)N)r% )__name__
__module__ __qualname__r- r. r: rG rC r+ r+ r+ r, r$ 4 s
$r$ c @ s| e Zd ZdZdd Zeje ddd Zdd Z eje dd d
Z
eje d d d
Z eje d dd Z
dS )TestUnconnectedSocketsz;Tests sockets which are open but not connected to anything.c
C sF dt f}tttt|d }| j|}| j|jtj W d Q R X d S )Nz 127.0.0.1)addr)
r r r r r rG r7 statusrI CONN_LISTEN)r) rP r9 rF r+ r+ r, test_tcp_v4 s
z"TestUnconnectedSockets.test_tcp_v4zIPv6 not supportedc
C sF dt f}tttt|d }| j|}| j|jtj W d Q R X d S )Nz::1)rP )
r r r r r rG r7 rQ rI rR )r) rP r9 rF r+ r+ r, test_tcp_v6 s
z"TestUnconnectedSockets.test_tcp_v6c
C sF dt f}tttt|d }| j|}| j|jtj W d Q R X d S )Nz 127.0.0.1)rP )
r r r r r rG r7 rQ rI CONN_NONE)r) rP r9 rF r+ r+ r, test_udp_v4 s
z"TestUnconnectedSockets.test_udp_v4c
C sF dt f}tttt|d }| j|}| j|jtj W d Q R X d S )Nz::1)rP )
r r r r r rG r7 rQ rI rU )r) rP r9 rF r+ r+ r, test_udp_v6 s
z"TestUnconnectedSockets.test_udp_v6z
POSIX onlyc C sL t <}tt|td }| j|}| j|jtj W d Q R X W d Q R X d S )N)r= ) r! r r r rG r7 rQ rI rU )r) namer9 rF r+ r+ r,
test_unix_tcp s
z$TestUnconnectedSockets.test_unix_tcpc C sL t <}tt|td }| j|}| j|jtj W d Q R X W d Q R X d S )N)r= ) r! r r r rG r7 rQ rI rU )r) rX r9 rF r+ r+ r,
test_unix_udp s
z$TestUnconnectedSockets.test_unix_udpN)rL rM rN __doc__rS r skipIfr rT rV rW r rY rZ r+ r+ r+ r, rO s rO c @ sT e Zd ZdZejeddd Zeje ddd Z e
e dd d
Z d d Z
d
S )TestConnectedSocketPairszJTest socket pairs which are are actually connected to
each other.
zunreliable on SUONSc
C sz dt f}tt|d\}}zHtjdd}| jt|d | j|d jtj | j|d jtj W d |j
|j
X d S )Nz 127.0.0.1)rP tcp4)r& r; r r3 ) r r r r' r( r7 r8 rQ rI ZCONN_ESTABLISHEDclose)r) rP serverclientr* r+ r+ r, test_tcp s
z!TestConnectedSocketPairs.test_tcpz
POSIX onlyc C s2 t }t|\}}ztjdd}tr6dd |D }| jt|d tsRtsRt r| j|d j
d | j|d j
d | j||d j p|d j nzt rxt|d j |d j
|d j |d j
fD ]}| j|d qW n:| j|d j p|d j | | j|d j
p|d j
| W d |j
|j
X W d Q R X d S ) Nunix)r& c S s g | ]}|j d kr|qS )z /var/run/log)raddr)r0 r1 r+ r+ r, r2 s z6TestConnectedSocketPairs.test_unix..r; r r3 )r! r" r' r( r r7 r8 r r r
rd rB r
r_ )r) rX r` ra r* rP r+ r+ r, test_unix s&
"z"TestConnectedSocketPairs.test_unix)Zonly_ifc s fdd}t jd}t jd}ddlm} tjjt}||jt t
d|d}||jt t
d|d}||jt t d |d}||jt t d |d} t |}
t
t|} t |} t
t|}
t rt |}t
t|}t | }t
t|}nd }d }d }d } xtj D ]}|j } jt|d
x|D ]}|j|
jkr\|||t
t| f tjd n|j| jkr|||t
t|
f tjd nZ|jt|dd kr|||t t|f tjd n,|jt|dd kr0|||t t|f tjd q0W q W j t |jdd d S ) Nc
s d }t | j|j| j|j| j|j| j|j| j|j| x"|D ]} | j| d }
| |krXqXqXW tr j | j
|g d S )
Nr% inetinet4inet6tcpr^ tcp6udpudp4udp6)r& )
r% rg rh ri rj r^ rk rl rm rn ) r r7 r< r= rB rd rQ r( r rC rH ) procrF r< r= rB rd rQ ZkindsZ all_kindsr& r* )r) r+ r,
check_conn s
z8TestConnectedSocketPairs.test_combos..check_conna
import socket, time
s = socket.socket($family, socket.SOCK_STREAM)
s.bind(('$addr', 0))
s.listen(1)
with open('$testfn', 'w') as f:
f.write(str(s.getsockname()[:2]))
time.sleep(60)
z
import socket, time
s = socket.socket($family, socket.SOCK_DGRAM)
s.bind(('$addr', 0))
with open('$testfn', 'w') as f:
f.write(str(s.getsockname()[:2]))
time.sleep(60)
r )Templatez 127.0.0.1)r< rP Ztestfnz::1r3 r% rg rh rj r^ rl rm rH ri rk rn z???)r& )r% rg rh rj r^ )r% rg rh rl rm )r% rg ri rj rk )r% rg ri rl rn ) textwrapdedentstringrq rD pathbasenamer Z
substituteintr r r evalr# r r' Zchildrenr( r7 r8 rH r rI rR r rU getattr assertRaises
ValueError)r) rp Z tcp_templateZ udp_templaterq ZtestfileZ
tcp4_templateZ
udp4_templateZ
tcp6_templateZ
udp6_templateZ tcp4_procZ tcp4_addrZ udp4_procZ udp4_addrZ tcp6_procZ tcp6_addrZ udp6_procZ udp6_addrpr* rF r+ )r) r, test_combos sb
z$TestConnectedSocketPairs.test_combosc C s t }tjdd}| jt|t| tjdd}| jt|t rJdnd x,|D ]$}| j|jtt f | j|j
t qVW tjdd}| jt|d | j|d jt | j|d j
t t rtjdd}| jt|d | j|d jt | j|d j
t tjd d}| jt|t r(dnd x.|D ]&}| j|jtt f | j|j
t q4W tjd
d}| jt|d | j|d jt | j|d j
t t rtjd d}| jt|d | j|d jt | j|d j
t tjd d}| jt|t rd
nd x2|D ]*}| j|jtt f | j|j
t t f qW t rtjdd}| jt|d x.|D ]&}| j|jt | j|j
t t f qlW t
rtjdd}| jt|d x.|D ]&}| j|jt | j|j
t t f qW W d Q R X d S )Nr% )r& rj r; r3 r^ r rk rl rm rn rg ri rc )r r' r( r7 r8 r assertInr< r r r= r r r r )r) socksr* rF r+ r+ r, test_multi_sockets_filteringe s`
z5TestConnectedSocketPairs.test_multi_sockets_filteringN)rL rM rN r[ r r\ r
rb r rf r r r} r r+ r+ r+ r, r] s
!br] c @ sJ e Zd ZdZe dd Ze dd Ze eje o6e
ddd Z d S )
TestSystemWideConnectionsz Tests for net_connections().c
s fdd}t ddlm} xZ|j D ]N\}}|dkrBt rBq*|\}}tj|} jt|tt | |||| q*W j
t tjdd W d Q R X d S )Nc sV t tdt }xB| D ]:} j|j||d |j|krF j|j||d t| qW d S )Nr )msg)ry r> objectr r< r= r )r* familiestypes_r rF )r) r+ r, check s
z0TestSystemWideConnections.test_it..checkr ) conn_tmaprc z???)r& ) r psutil._commonr itemsr rI rJ r7 r8 setrz r{ )r) r r r& groupsr r r* r+ )r) r, test_it s
z!TestSystemWideConnections.test_itc C s@ t 0}dd tjddD }| jt|t| W d Q R X d S )Nc S s g | ]}|j tj kr|qS r+ )rH rD rE )r0 xr+ r+ r, r2 s z>TestSystemWideConnections.test_multi_socks..r% )r& )r rI rJ r7 r8 )r) r r* r+ r+ r, test_multi_socks s z*TestSystemWideConnections.test_multi_sockszunreliable on OSX + TRAVISc
s t }t|}W d Q R X g d}xRt|D ]F}tjjtt| }tj d| }t
|}j |j | j
t| q,W x$t|D ]}tt| }t| qW fddtjddD }xJD ]B | jt fdd|D | tj } | jt| jd| qW d S )N
a import time, os
from psutil.tests import create_sockets
with create_sockets():
with open('%s', 'w') as f:
f.write(str(os.getpid()))
time.sleep(60)
c s g | ]}|j kr|qS r+ )rH )r0 r )pidsr+ r, r2 s zFTestSystemWideConnections.test_multi_sockets_procs..r% )r& c s g | ]}|j kr|qS r+ )rH )r0 r )rH r+ r, r2 s )r r8 rangerD ru realpathr strrr rs r appendrH Z
addCleanupr r# rI rJ r7 Processr( )
r) r ZexpectedtimesiZfnamesrcZsprocZsysconsr| r+ )rH r r, test_multi_sockets_procs s(
z2TestSystemWideConnections.test_multi_sockets_procsN) rL rM rN r[ r r r r r\ r r r r+ r+ r+ r, r s
r c @ s e Zd Zdd ZdS )TestMiscc C s g }g }xXt tD ]L}|jdrtt|}t|}| jt| | j|| |j| |j| qW trrtj tj t
r|tj d S )NZCONN_) dirrI
startswithry r Z assertNotInr r
Z CONN_IDLEZ
CONN_BOUNDr ZCONN_DELETE_TCB)r) ZintsZstrsrX ZnumZstr_r+ r+ r, test_connection_constants s
z"TestMisc.test_connection_constantsN)rL rM rN r r+ r+ r+ r, r s r __main__)6r[ rD r> rr
contextlibr r r r r rI r r r r
r r r
r r r Zpsutil._compatr Z psutil.testsr r r r r r r r r r r r r r r r r! r" r# r r' r r$ ZTestCaserO r] r r rL __file__r+ r+ r+ r, s^ \7 `P
PK ! y\P P ' __pycache__/test_process.cpython-36.pycnu [ 3
JZ9 @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlm Z ddlm Z ddlm Z ddlm Z ddlm Z ddlm!Z! ddlm"Z" ddlm#Z# ddlm$Z$ ddlm%Z% ddlm&Z& ddlm'Z' ddlm(Z( ddlm)Z) dd lm*Z* dd lm+Z+ dd lm,Z, dd lm-Z- dd lm.Z. dd!lm/Z/ dd"lm0Z0 dd#lm1Z1 dd$lm2Z2 dd%lm3Z3 dd&lm4Z4 dd'lm5Z5 dd(lm6Z6 dd)lm7Z7 dd*lm8Z8 dd+lm9Z9 dd,lm:Z: dd-lm;Z; dd.lmZ?erej@ dkrG d2d3 d3e?ZAG d4d5 d5e;j>ZBeCd6kre2eD dS )7z Tests for psutil.Process class. N)AIX)BSD)LINUX)NETBSD)OPENBSD)OSX)POSIX)SUNOS)WINDOWS)long)PY3)APPVEYOR)
call_until)copyload_shared_lib)
create_exe)create_proc_children_pair)create_zombie_proc)enum)get_test_subprocess)
get_winver)HAS_CPU_AFFINITY) HAS_ENVIRON)
HAS_IONICE)HAS_MEMORY_MAPS)HAS_PROC_CPU_NUM)HAS_PROC_IO_COUNTERS)
HAS_RLIMIT) HAS_THREADS)mock)PYPY)
PYTHON_EXE)
reap_children)retry_before_failing)run_test_module_by_name) safe_rmpath)sh)skip_on_access_denied)skip_on_not_implemented)TESTFILE_PREFIX)TESTFN)
ThreadTask)TRAVIS)unittest) wait_for_pid) WIN_VISTAc @ sr e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zdd Zeje d d d Zd d Zeje d!ejed"d#d$ Zeje d eed%d&d' Z eje d eje oe e k d d(d) Z!eje d eje o e e k d d*d+ Z"eje# d d,d- Z$eje# d d.d/ Z%eje# d d0d1 Z&eje# d d2d3 Z'eje# d d4d5 Z(d6d7 Z)eje d8d9d: Z*eje+ d d;d< Z,e- e.e/d%eje+ d d=d> Z0d?d@ Z1dAdB Z2eje3 d dCdD Z4eje3 d dEdF Z5dGdH Z6dIdJ Z7dKdL Z8dMdN Z9dOdP Z:eje;dQejeeje d!dWdX Z?dYdZ Z@d[d\ ZAd]d^ ZBd_d` ZCdadb ZDejeE d dcdd ZFejeE d dedf ZGejeE d dgdh ZHejeIdiejeJdjdkdl ZKejeIdiejeJdjdmdn ZLeje d!dodp ZMeed%ejeNpzeOdqdrds ZPdtdu ZQdvdw ZRdxdy ZSdzd{ ZTd|d} ZUd~d ZVdd ZWdd ZXdd ZYdd ZZdd Z[dd Z\eje d!dd Z]eje d!dd Z^eje d!dd Z_dd Z`ejea d dd Zbejea d eje d!dd ZcdS ) TestProcessz Tests for psutil.Process class.c C s t t d S )N)r$ r) )self r1 $/usr/lib64/python3.6/test_process.pysetUpN s zTestProcess.setUpc C s
t d S )N)r! )r0 r1 r1 r2 tearDownQ s zTestProcess.tearDownc C sX t j }| j|jtj t }| jt j|jj|j | jt d|_W d Q R X d S )N! ) psutilProcess assertEqualpidosgetpidr assertRaisesAttributeError)r0 psprocr1 r1 r2 test_pidT s zTestProcess.test_pidc C sN t }|j}tj|}|j |j }| jtj| trJ| j |t
j d S )N) r r9 r6 r7 killwait assertFalse
pid_existsr r8 signalSIGKILL)r0 r? r@ r> sigr1 r1 r2 test_kill\ s
zTestProcess.test_killc C sN t }|j}tj|}|j |j }| jtj| trJ| j |t
j d S )N) r r9 r6 r7 terminaterB rC rD r r8 rE SIGTERM)r0 r? r@ r> rG r1 r1 r2 test_terminatef s
zTestProcess.test_terminatec C sL t r
tjntj}t }tj|j}|j| |j }| j
tj |j t rH| j || t }tj|j}|j| t
jdttjdd( | jtj |j| W d Q R X W d Q R X t }tj|j}|j| t
jdttjdd, | jtj tj j| W d Q R X W d Q R X dtj krHtjd}| jt|jtj d S )Nzpsutil.os.kill ) side_effectr )r rE rF rJ r r6 r7 r9 send_signalrB rC rD r8 r patchOSErrorerrnoZESRCHr<
NoSuchProcessZEPERM AccessDeniedpids
ValueError)r0 rG r? r> Zexit_sigr1 r1 r2 test_send_signalp s2
"
z TestProcess.test_send_signalc C s^ t }tj|j}|j |j }tr8| j|tj n| j|tj
| j |j t }tj|j}|j
|j }tr| j|tj
n| j|tj
| j |j d}t td|g}tj|j}| j|j d | j |j t td|g}tj|j}| j|j d | j|j d t }tj|j}|j | jtj|jd | jt|jd d S )Nz0import time, sys; time.sleep(0.01); sys.exit(5);z-c g{Gz? )rW N)r r6 r7 r9 rA rB r r8 rE rF rJ rC
is_runningrI r assertInnamer< TimeoutExpiredrU )r0 r? r> coder1 r1 r2 test_wait s< zTestProcess.test_waitc C s t \}}| jtj|jd | jtj|jd |j |j |j }|j }trp| j|tj | j|d n | j|tj | j|tj d S )Ng{Gz?)
r r< r6 r] rB rI r r8 rE rJ )r0 p1p2Zret1Zret2r1 r1 r2 test_wait_non_children s
z"TestProcess.test_wait_non_childrenc C s t }tj|j}| jtj|jd |j tj d }x:y|jd}W n$ tjk
rl tj |krh Y q:X P q:W t r| j
|t j n| j
|t j
| j|j d S )Nr )r r6 r7 r9 r< r] rB rA timer r8 rE rF rJ rC rZ )r0 r? r> Zstop_atr^ r1 r1 r2 test_wait_timeout_0 s z TestProcess.test_wait_timeout_0c
C s t j }|jdd |jdd xRtdD ]F}|jd d}| j|t | j|d tsd| j|d q*| j|d q*W | j t
|jdd W d Q R X d S )NgMbP?)Zintervald g g Y@rX rY ) r6 r7 cpu_percentrangeassertIsInstancefloatassertGreaterEqualr assertLessEqualr< rU )r0 r> xZpercentr1 r1 r2 test_cpu_percent s z TestProcess.test_cpu_percentc C s4 t jdd d }tj j |js&tW d Q R X d S )Nzpsutil.cpu_count)Z return_value)r rO r6 r7 rg calledAssertionError)r0 mr1 r1 r2 test_cpu_percent_numcpus_none s z)TestProcess.test_cpu_percent_numcpus_nonec C sx t j j }|jdks(|jdks(t||jdks:t||jdksLt|x&|jD ] }t j
dt j t || qTW d S )Ng z%H:%M:%S)
r6 r7 cpu_timesusersystemrp
children_userchildren_system_fieldsrd strftime localtimegetattr)r0 timesr\ r1 r1 r2 test_cpu_times s zTestProcess.test_cpu_timesc C s t j j d d \}}tj d d \}}t||gt||g dkrZ| jd||f t||gt||g dkr| jd||f d S )Nrc g?zexpected: %s, found: %s)r6 r7 rs r: r| maxminfail)r0 user_timeZ kernel_timeutimeZktimer1 r1 r2 test_cpu_times_2 s z TestProcess.test_cpu_times_2z
not supportedc C sP t j }|j }| j|d t j dkr4| j|d | j|j tt j d S )Nr rX )r6 r7 Zcpu_numrk cpu_countr8 r[ rh )r0 r> Znumr1 r1 r2 test_cpu_num s zTestProcess.test_cpu_numc C sd t }tj }tj|j}|j }t|| }|dkrJ| jd|||f tjdtj |j d S )Nrc z'expected: %s, found: %s, difference: %sz%Y %m %d %H:%M:%S)
r rd r6 r7 r9 create_timeabsr ry rz )r0 r? Znowr> r
differencer1 r1 r2 test_create_time s z TestProcess.test_create_timez
POSIX onlyznot reliable on TRAVISc C sL t j j }tjj s tjj r>tjj t
d}| j || n
| j | d S )Ntty)
r6 r7 terminalsysstdinisattystdoutr: pathrealpathr% r8 assertIsNone)r0 r r r1 r1 r2
test_terminal- s
zTestProcess.test_terminal)Zonly_ifc C s t j }|j }ttd}|j W d Q R X |j }t rt r| j|j |j | j
|j |j t r| j|j
|j
| j
|j|j n | j|j|j | j|j|j |j }tjtd.}tr|jtdd d n|jdd W d Q R X |j }| j|j |j | j|j|j | j|j |j | j|j|j t r^| j|j|j | j|j
|j
xJtt|D ]:}tr|dkrql| j|| d | j|| d qlW d S )Nrb)prefixrm i@B asciirc r )r6 r7 Z io_countersopenr readr r
assertGreaterZ
read_countr8 Z write_countr Z
read_charsZ write_charsrk Z
read_bytesZ write_bytestempfileZ
TemporaryFiler( r writebytesrh len)r0 r> Zio1fZio2ir1 r1 r2 test_io_counters7 s> z TestProcess.test_io_countersc C s t r Zioclassvalueoriginalr1 r1 r2 test_ionicec sJ
zTestProcess.test_ionicec C s t }tj|j}tr| jt|jdd | jt|jdd | jt|jd | jt|jdd | j td|jtj
d | j td|jtj d | j td|jdd n"| jt|jd
| jt|jdd d S ) Nrc
rX r fooz*can't specify value with IOPRIO_CLASS_NONEz*can't specify value with IOPRIO_CLASS_IDLEz$'ioclass' argument must be specified)r r rY ) r r6 r7 r9 r r< rU r TypeErrorZassertRaisesRegexr r )r0 r? r> r1 r1 r2 test_ionice_errs s$ z TestProcess.test_ionice_errsc C s dd l }tjtj }dd ttD }|s4t|x|D ]}tt|}| j|d |t|kr| j |t|| t
rxq:| j |j ||j | q:|j |}| j t
|d | j|d d | j|d d q:W d S )Nr c S s g | ]}|j d r|qS )ZRLIMIT)
startswith).0rm r1 r1 r2
s z/TestProcess.test_rlimit_get..rc rX rY rY )resourcer6 r7 r: r; dirrp r{ rk r8 r rlimitZ getrlimitr )r0 r r> namesr\ r retr1 r1 r2 test_rlimit_get s
zTestProcess.test_rlimit_getc C s t }tj|j}|jtjd | j|jtjd | jt tj jdjd W d Q R X | jt |jtjd W d Q R X d S )NrW r )rW rW )rW rW )rW rW rW )
r r6 r7 r9 r
RLIMIT_NOFILEr8 r< rU Z _psplatform)r0 r? r> r1 r1 r2 test_rlimit_set s zTestProcess.test_rlimit_setc C s t j }|jt j\}}z|jt jd|f ttd}|jdd W d Q R X | jt*}ttd}|jdd W d Q R X W d Q R X | j t
r|j j n|j d t j
W d |jt j||f | j |jt j||f X d S )Ni wb Xi r )r6 r7 r RLIMIT_FSIZEr r) r r< IOErrorr8 r Z exceptionrQ ZEFBIG)r0 r> softhardr excr1 r1 r2 test_rlimit s " zTestProcess.test_rlimitc C s t j }|jt j\}}zN|jt jd|f |jt jt j|f ttd}|jdd W d Q R X W d |jt j||f | j|jt j||f X d S )Ni r r i ) r6 r7 r r
RLIM_INFINITYr r) r r8 )r0 r> r r r r1 r1 r2 test_rlimit_infinity s z TestProcess.test_rlimit_infinityc C s< t j }|jt j\}}| jt j| |jt j||f d S )N)r6 r7 r r r8 r )r0 r> r r r1 r1 r2 test_rlimit_infinity_value s z&TestProcess.test_rlimit_infinity_valuec C sr t j }tr step1step2r1 r1 r2 test_num_threads s z TestProcess.test_num_threadsz WINDOWS onlyc C s t j }| j|j d d S )Nr )r6 r7 r Z num_handles)r0 r> r1 r1 r2 test_num_handles s z TestProcess.test_num_handlesc C s t j }tr r r Zathreadr1 r1 r2 test_threads s zTestProcess.test_threadsc
C s t }tj|j}trDy |j W n tjk
rB tjdY nX | j |j
j t dd |j D dd | j |j
j
t dd |j D dd d S )Nz$on OpenBSD this requires root accessc S s g | ]
}|j qS r1 )r )r rm r1 r1 r2 r 7 s z.TestProcess.test_threads_2..g?)Zdeltac S s g | ]
}|j qS r1 )r )r rm r1 r1 r2 r : s )r r6 r7 r9 r r rS r, r ZassertAlmostEqualrs rt sumru )r0 r? r> r1 r1 r2 test_threads_2) s zTestProcess.test_threads_2c C s t j }|j d d \}}|j }| j|d | j|d d gd }|j d d \}}|j }| j|| | j|| | j|| ~tr|j } | j| j| j | j| j
| j |j } x | j D ]}
| jt
| |
d qW d S )Nrc r i` )r6 r7 Z memory_infomemory_percentr rk r
r8 ZrssZwsetvmsZpagefilerx r{ ) r0 r> Zrss1Zvms1Zpercent1ZmemarrZrss2Zvms2Zpercent2memr\ r1 r1 r2 test_memory_info< s&
z TestProcess.test_memory_infoc C s t j j}t j j }xB|jD ]8}t||}| j|d||fd | j|||||fd q W t sft
sft rt| j|j d t r| j|j
d | j|jd d S )Nr )msg)r6 Zvirtual_memorytotalr7 Zmemory_full_inforx r{ rk rl r r
r ussZpssZswap)r0 r r r\ r r1 r1 r2 test_memory_full_infoZ s
z!TestProcess.test_memory_full_infoc
C s t j }|j }dd |D }| jt|tt| |jdd}x|D ]}|jjdsHtjj |jspt
|jt ry*tjj |jstjj
|jst
|jW nH t
k
r ts n,td}|j }W d Q R X d|j |kr Y nX qHdtjj|jkrHtjj |jsHt
|jqHW xv|D ]n}xf|jD ]\}t||} |d krHq*n<|d
krb| st
| n"| j| ttf | d ks*t
| q*W q W d S )Nc S s g | ]}|qS r1 r1 )r rm r1 r1 r2 r k s z0TestProcess.test_memory_maps..F)Zgrouped[z/proc/self/smapsz %s (deleted)Z64r addrpermsr )r r )r6 r7 memory_mapsr8 r setr r r: isabsrp r existsislinkr r r basenamerx r{ ri r r )
r0 r> mapspathsZext_mapsntr dataZfnamer r1 r1 r2 test_memory_mapsg s<
z TestProcess.test_memory_mapsc
sH t 8}dd fddtj j D }| j || W d Q R X d S )Nc S s t jjt jj| S )N)r: r r normcase)r> r1 r1 r2 normpath s z8TestProcess.test_memory_maps_lists_lib..normpathc s g | ]} |j qS r1 )r )r rm )r r1 r2 r s z:TestProcess.test_memory_maps_lists_lib..