Add self-freeing diagnostic instance counting and leak test

srajko · srajko · commit acd9bedf8c8b · 2016-03-23T16:20:45.000-07:00
diff --git a/generate/templates/templates/class_content.cc b/generate/templates/templates/class_content.cc
@@ -27,12 +27,21 @@ using namespace node;
   {{ cppClassName }}::{{ cppClassName }}({{ cType }} *raw, bool selfFreeing) {
     this->raw = raw;
     this->selfFreeing = selfFreeing;
+
+    if (selfFreeing) {
+      SelfFreeingInstanceCount++;
+    } else {
+      NonSelfFreeingConstructedCount++;
+    }
+
   }
 
   {{ cppClassName }}::~{{ cppClassName }}() {
     {% if freeFunctionName %}
       if (this->selfFreeing) {
         {{ freeFunctionName }}(this->raw);
+        SelfFreeingInstanceCount--;
+
         this->raw = NULL;
       }
     {% endif %}
@@ -77,6 +86,9 @@ using namespace node;
       {% endif %}
     {% endeach %}
 
+    Nan::SetMethod(tpl, "getSelfFreeingInstanceCount", GetSelfFreeingInstanceCount);
+    Nan::SetMethod(tpl, "getNonSelfFreeingConstructedCount", GetNonSelfFreeingConstructedCount);
+
     Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
     constructor_template.Reset(_constructor_template);
     Nan::Set(target, Nan::New("{{ jsClassName }}").ToLocalChecked(), _constructor_template);
@@ -104,6 +116,14 @@ using namespace node;
     return scope.Escape(Nan::NewInstance(Nan::New({{ cppClassName }}::constructor_template), 2, argv).ToLocalChecked());
   }
 
+  NAN_METHOD({{ cppClassName }}::GetSelfFreeingInstanceCount) {
+    info.GetReturnValue().Set(SelfFreeingInstanceCount);
+  }
+
+  NAN_METHOD({{ cppClassName }}::GetNonSelfFreeingConstructedCount) {
+    info.GetReturnValue().Set(NonSelfFreeingConstructedCount);
+  }
+
   {{ cType }} *{{ cppClassName }}::GetValue() {
     return this->raw;
   }
@@ -147,3 +167,6 @@ using namespace node;
 {% if not cTypeIsUndefined %}
   Nan::Persistent<Function> {{ cppClassName }}::constructor_template;
 {% endif %}
+
+int {{ cppClassName }}::SelfFreeingInstanceCount;
+int {{ cppClassName }}::NonSelfFreeingConstructedCount;
diff --git a/generate/templates/templates/class_header.h b/generate/templates/templates/class_header.h
@@ -40,6 +40,10 @@ class {{ cppClassName }} : public Nan::ObjectWrap {
 
     static Nan::Persistent<Function> constructor_template;
     static void InitializeComponent (Local<v8::Object> target);
+    // diagnostic count of self-freeing object instances
+    static int SelfFreeingInstanceCount;
+    // diagnostic count of constructed non-self-freeing object instances
+    static int NonSelfFreeingConstructedCount;
 
     {%if cType%}
     {{ cType }} *GetValue();
@@ -96,6 +100,8 @@ class {{ cppClassName }} : public Nan::ObjectWrap {
     {% endeach %}
 
     static NAN_METHOD(JSNewFunction);
+    static NAN_METHOD(GetSelfFreeingInstanceCount);
+    static NAN_METHOD(GetNonSelfFreeingConstructedCount);
 
     {%each fields as field%}
       {%if not field.ignore%}
diff --git a/test/tests/commit.js b/test/tests/commit.js
@@ -9,6 +9,25 @@ var exec = promisify(function(command, opts, callback) {
   return require("child_process").exec(command, opts, callback);
 });
 
+// aggressively collects garbage until we fail to improve terminatingIterations
+// times.
+function garbageCollect() {
+  var terminatingIterations = 3;
+  var usedBeforeGC = Number.MAX_VALUE;
+  var nondecreasingIterations = 0;
+  for ( ; ; ) {
+    global.gc();
+    var usedAfterGC = process.memoryUsage().heapUsed;
+    if (usedAfterGC >= usedBeforeGC) {
+      nondecreasingIterations++;
+      if (nondecreasingIterations >= terminatingIterations) {
+        break;
+      }
+    }
+    usedBeforeGC = usedAfterGC;
+  }
+}
+
 describe("Commit", function() {
   var NodeGit = require("../../");
   var Repository = NodeGit.Repository;
@@ -624,4 +643,33 @@ describe("Commit", function() {
       assert.equal(this.committer.email(), "mike@panmedia.co.nz");
     });
   });
+
+  it("does not leak", function() {
+    var test = this;
+
+    garbageCollect();
+    var Commit = NodeGit.Commit;
+    var startSelfFreeingCount = Commit.getSelfFreeingInstanceCount();
+    var startNonSelfFreeingCount = Commit.getNonSelfFreeingConstructedCount();
+
+    var resolve;
+    var promise = new Promise(function(_resolve) { resolve = _resolve; });
+
+    NodeGit.Commit.lookup(test.repository, oid)
+      .then(function() {
+        // get out of this promise chain to help GC get rid of the commit
+        setTimeout(resolve, 0);
+      });
+
+    return promise
+      .then(function() {
+        garbageCollect();
+        var endSelfFreeingCount = Commit.getSelfFreeingInstanceCount();
+        var endNonSelfFreeingCount = Commit.getNonSelfFreeingConstructedCount();
+        // any new self-freeing commits should have been freed
+        assert.equal(startSelfFreeingCount, endSelfFreeingCount);
+        // no new non-self-freeing commits should have been constructed
+        assert.equal(startNonSelfFreeingCount, endNonSelfFreeingCount);
+      });
+  });
 });
