@depup/node-memwatch 1.0.1-depup.0

package/src/platformcompat.hh

@@ -0,0 +1,19 @@
+#ifndef __PLATFORMCOMPAT_H
+#define __PLATFORMCOMPAT_H
+
+#if defined(_MSC_VER)
+#include <float.h> //isinf, isnan
+#include <stdlib.h> //min
+#define ISINF _finite
+#define ISNAN _isnan
+#define FMIN __min
+#define ROUND(x) floor(x + 0.5)
+#else
+#include <cmath> // round(), isinf, isnan
+#define ISINF std::isinf
+#define ISNAN std::isnan
+#define FMIN fmin
+#define ROUND round
+#endif
+
+#endif

package/src/util.cc

@@ -0,0 +1,46 @@
+/*
+ * 2012|lloyd|http://wtfpl.org
+ */
+
+#include "platformcompat.hh"
+#include "util.hh"
+
+#include <sstream>
+
+#include <stdlib.h> // abs()
+
+std::string
+mw_util::niceSize(int bytes) 
+{
+    std::stringstream ss;
+    
+    if (abs(bytes) > 1024 * 1024) {
+        ss << ROUND(bytes / (((double) 1024 * 1024 ) / 100)) / (double) 100 << " mb";
+    } else if (abs(bytes) > 1024) {
+        ss << ROUND(bytes / (((double) 1024 ) / 100)) / (double) 100 << " kb";
+    } else {
+        ss << bytes << " bytes";
+    }
+    
+    return ss.str();
+}
+
+std::string
+mw_util::niceDelta(int seconds) 
+{
+    std::stringstream ss;
+
+    if (seconds > (60*60)) {
+        ss << (seconds / (60*60)) << "h ";
+        seconds %= (60*60);
+    }
+
+    if (seconds > (60)) {
+        ss << (seconds / (60)) << "m ";
+        seconds %= (60);
+    }
+    
+    ss << seconds << "s";
+
+    return ss.str();
+}

package/src/util.hh

@@ -0,0 +1,16 @@
+/*
+ * 2012|lloyd|http://wtfpl.org
+ */
+
+#include <string>
+
+namespace mw_util {
+    // given a size in bytes, return a human readable representation of the
+    // string
+    std::string niceSize(int bytes);
+
+    // given a delta in seconds, return a human redable representation
+    std::string niceDelta(int seconds);
+};
+
+

package/tests.js

@@ -0,0 +1,64 @@
+const
+should = require('should'),
+memwatch = require('./');
+
+describe('the library', function() {
+  it('should export a couple functions', function(done) {
+    should.exist(memwatch.gc);
+    should.exist(memwatch.on);
+    should.exist(memwatch.once);
+    should.exist(memwatch.removeAllListeners);
+    should.exist(memwatch.HeapDiff);
+    done();
+  });
+});
+describe('calling .gc()', function() {
+  it('should cause a stats() event to be emitted', function(done) {
+    memwatch.once('stats', function(s) {
+      s.should.be.object;
+      done();
+    });
+    memwatch.gc();
+  });
+});
+
+describe('HeapDiff', function() {
+  it('should detect allocations', function(done) {
+    function LeakingClass() {};
+    var arr = [];
+    var hd = new memwatch.HeapDiff();
+    for (var i = 0; i < 100; i++) arr.push(new LeakingClass());
+    var diff = hd.end();
+    (Array.isArray(diff.change.details)).should.be.ok;
+    diff.change.details.should.be.an.instanceOf(Array);
+    // find the LeakingClass elem
+    var leakingReport;
+    diff.change.details.forEach(function(d) {
+      if (d.what === 'LeakingClass')
+        leakingReport = d;
+    });
+    should.exist(leakingReport);
+    ((leakingReport['+'] - leakingReport['-']) > 0).should.be.ok;
+    done();
+
+  });
+});
+
+describe('HeapDiff', function() {
+  it('double end should throw', function(done) {
+    var hd = new memwatch.HeapDiff();
+    var arr = [];
+    (function() { hd.end(); }).should.not.throw();
+    (function() { hd.end(); }).should.throw();
+    done();
+  });
+});
+
+describe('improper HeapDiff allocation', function() {
+  it('should throw an exception', function(done) {
+    // equivalent to "new require('memwatch').HeapDiff()"
+    // see issue #30
+    (function() { new (memwatch.HeapDiff()); }).should.throw();
+    done();
+  });
+});