net-snmp 3.15.2 → 3.16.0

package/.vscode/launch.json

@@ -15,7 +15,7 @@
             "args": [
                 "-v", "2c",
                 "-c", "public",
-                "-s", "5678",
+                "-s", "1162",
                 "127.0.0.1",
                 "1.3.6.1.2.1.31.1.1.1.6.1"
             ]

package/README.md

@@ -3424,6 +3424,14 @@ Example programs are included under the module's `example` directory.
 
  * Change return of non-existing OIDs under table from NoSuchObject to NoSuchInstance
 
+## Version 3.15.3 - 04/12/2024
+
+ * Fix agent SNMP SetRequest for OIDs
+
+## Version 3.16.0 - 23/12/2024
+
+ * Add MIB object validation to set/add MIB API calls
+
 # License
 
 Copyright (c) 2020 Mark Abrahams <mark@abrahams.co.nz>

package/example/option-parser.js

@@ -61,6 +61,9 @@ if ( command.includes('snmp-set') ) {
         type: snmp.ObjectType[options._[2]],
         value: options._[3]
     }];
+    if ( varbinds[0].type == snmp.ObjectType.Integer ) {
+        varbinds[0].value = Number(varbinds[0].value);
+    }
 } else if ( command.includes('snmp-table-columns') ) {
     oids = [options._[1]];
     columns = [];

package/index.js

@@ -585,6 +585,106 @@ function writeVarbinds (buffer, varbinds) {
 	buffer.endSequence ();
 }
 
+const ObjectTypeUtil = {};
+
+ObjectTypeUtil.castSetValue = function (type, value) {
+
+	switch (type) {
+		case ObjectType.Boolean:
+			return !! value;
+
+		case ObjectType.Integer:
+			if ( typeof value != "number" && typeof value != "string" ) {
+				throw new Error("Invalid Integer", value);
+			}
+			return typeof value == "number" ? value : parseInt(value, 10);
+
+		case ObjectType.OctetString:
+			if ( value instanceof Buffer) {
+				return value.toString();
+			} else if ( typeof value != "string" ) {
+				throw new Error("Invalid OctetString", value);
+			} else {
+				return value;
+			}
+
+		case ObjectType.OID:
+			if ( typeof value != "string" || ! value.match(/^([0-9]+)(\.[0-9]+)+$/) ) {
+				throw new Error("Invalid OID", value);
+			}
+			return value;
+
+		case ObjectType.Counter:
+		case ObjectType.Counter64:
+			// Counters should be initialized to 0 (RFC2578, end of section 7.9)
+			// We'll do so.
+			return 0;
+
+		case ObjectType.IpAddress:
+			// A 32-bit internet address represented as OCTET STRING of length 4
+			var bytes = value.split(".");
+			if ( typeof value != "string" || bytes.length != 4 ) {
+				throw new Error("Invalid IpAddress", value);
+			}
+			return value;
+
+		default :
+			// Assume the caller knows what he's doing
+			return value;
+	}
+
+};
+
+ObjectTypeUtil.isValid = function (type, value) {
+
+	switch (type) {
+		case ObjectType.Boolean: {
+			return typeof value == "boolean";
+		}
+		case ObjectType.Integer: {
+			// Allow strings that can be parsed as integers
+			const parsed = Number(value);
+			return ! isNaN (parsed) && Number.isInteger (parsed) && parsed >= MIN_SIGNED_INT32 && parsed <= MAX_SIGNED_INT32;
+		}
+		case ObjectType.OctetString: {
+			// Allow string or buffer
+			return typeof value == "string" || value instanceof Buffer;
+		}
+		case ObjectType.OID: {
+			return typeof value == "string" && value.match (/^([0-9]+)(\.[0-9]+)+$/);
+		}
+		case ObjectType.Counter: {
+			// Allow strings that can be parsed as integers
+			const parsed = Number(value);
+			return ! isNaN (parsed) && Number.isInteger (parsed) && parsed >= 0 && parsed <= MAX_UNSIGNED_INT32;
+		}
+		case ObjectType.Counter64: {
+			// Allow strings that can be parsed as integers
+			const parsed = Number(value);
+			return ! isNaN (parsed) && Number.isInteger (parsed) && parsed >= 0;
+		}
+		case ObjectType.IpAddress: {
+			const octets = value.split(".");
+			if ( octets.length !== 4 ) {
+				return false;
+			}
+			for ( const octet of octets ) {
+				if ( isNaN (octet) ) {
+					return false;
+				}
+				if ( parseInt (octet) < 0 || parseInt (octet) > 255) {
+					return false;
+				}
+			}
+			return true;
+		}
+		default: {
+			return false;
+		}
+	}
+
+};
+
 /*****************************************************************************
  ** PDU class definitions
  **/
@@ -3966,14 +4066,8 @@ Mib.prototype.getProviderNodeForInstance = function (instanceNode) {
 };
 
 Mib.prototype.addProviderToNode = function (provider) {
-	var node = this.addNodesForOid (provider.oid);
-
+	const node = this.addNodesForOid (provider.oid);
 	node.provider = provider;
-	if ( provider.type == MibProviderType.Table ) {
-		if ( ! provider.tableIndex ) {
-			provider.tableIndex = [1];
-		}
-	}
 	this.providerNodes[provider.name] = node;
 	return node;
 };
@@ -4183,8 +4277,11 @@ Mib.prototype.setScalarValue = function (scalarName, newValue) {
 		instanceNode = this.lookup (instanceAddress);
 		instanceNode.valueType = provider.scalarType;
 	}
+	const isValidValue = ObjectTypeUtil.isValid(instanceNode.valueType, newValue);
+	if ( ! isValidValue ) {
+		throw new TypeError(`Invalid value for ${scalarName} of type ${instanceNode.valueType}: ${newValue}`);
+	}
 	instanceNode.value = newValue;
-	// return instanceNode.setValue (newValue);
 };
 
 Mib.prototype.getProviderNodeForTable = function (table) {
@@ -4312,6 +4409,23 @@ Mib.prototype.getTableRowInstanceFromRowIndex = function (provider, rowIndex) {
 	return rowIndexOid;
 };
 
+Mib.prototype.validateTableRow = function (table, row) {
+	const provider = this.providers[table];
+	const tableIndex = provider.tableIndex;
+	const foreignIndexOffset = tableIndex.filter ( indexPart => indexPart.foreign ).length;
+	for ( let i = 0; i < provider.tableColumns.length ; i++ ) {
+		const column = provider.tableColumns[i];
+		const isColumnIndex = tableIndex.some ( indexPart => indexPart.columnNumber == column.number );
+		if ( ! isColumnIndex || ! (column.maxAccess === MaxAccess['not-accessible'] || column.maxAccess === MaxAccess['accessible-for-notify']) ) {
+			const rowValueIndex = foreignIndexOffset + i;
+			const isValidValue = ObjectTypeUtil.isValid(column.type, row[rowValueIndex]);
+			if ( ! isValidValue ) {
+				throw new TypeError(`Invalid value for ${table} column ${column.name} (index ${rowValueIndex}): ${row[rowValueIndex]} (in row [${row}])`);
+			}
+		}
+	}
+};
+
 Mib.prototype.addTableRow = function (table, row) {
 	var providerNode;
 	var provider;
@@ -4320,7 +4434,11 @@ Mib.prototype.addTableRow = function (table, row) {
 	var instanceNode;
 	var rowValueOffset;
 
-	if ( this.providers[table] && ! this.providerNodes[table] ) {
+	if ( ! this.providers[table] ) {
+		throw new ReferenceError ("Provider " + table + " not registered with this MIB");
+	}
+	this.validateTableRow (table, row);
+	if ( ! this.providerNodes[table] ) {
 		this.addProviderToNode (this.providers[table]);
 	}
 	providerNode = this.getProviderNodeForTable (table);
@@ -4450,19 +4568,16 @@ Mib.prototype.getTableSingleCell = function (table, columnNumber, rowIndex) {
 };
 
 Mib.prototype.setTableSingleCell = function (table, columnNumber, rowIndex, value) {
-	var provider;
-	var providerNode;
-	var columnNode;
-	var instanceNode;
-	var instanceAddress;
-
-	provider = this.providers[table];
-	providerNode = this.getProviderNodeForTable (table);
-	instanceAddress = this.getTableRowInstanceFromRowIndex (provider, rowIndex);
-	columnNode = providerNode.children[columnNumber];
-	instanceNode = columnNode.getInstanceNodeForTableRowIndex (instanceAddress);
+	const provider = this.providers[table];
+	const providerNode = this.getProviderNodeForTable (table);
+	const instanceAddress = this.getTableRowInstanceFromRowIndex (provider, rowIndex);
+	const columnNode = providerNode.children[columnNumber];
+	const instanceNode = columnNode.getInstanceNodeForTableRowIndex (instanceAddress);
+	const isValidValue = ObjectTypeUtil.isValid(instanceNode.valueType, value);
+	if ( ! isValidValue ) {
+		throw new TypeError(`Invalid value for ${table} column ${columnNumber} of type ${instanceNode.valueType}: ${value}`);
+	}
 	instanceNode.value = value;
-	// return instanceNode.setValue (value);
 };
 
 Mib.prototype.deleteTableRow = function (table, rowIndex) {
@@ -4742,53 +4857,6 @@ Agent.prototype.onMsg = function (socket, buffer, rinfo) {
 	}
 };
 
-Agent.prototype.castSetValue = function ( type, value ) {
-	switch (type) {
-		case ObjectType.Boolean:
-			return !! value;
-
-		case ObjectType.Integer:
-			if ( typeof value != "number" && typeof value != "string" ) {
-				throw new Error("Invalid Integer", value);
-			}
-			return typeof value == "number" ? value : parseInt(value, 10);
-
-		case ObjectType.OctetString:
-			if ( value instanceof Buffer) {
-				return value.toString();
-			} else if ( typeof value != "string" ) {
-				throw new Error("Invalid OctetString", value);
-			} else {
-				return value;
-			}
-
-		case ObjectType.OID:
-			if ( typeof value != "string" || ! value.match(/[0-9]+\([.][0-9]+\)+/) ) {
-				throw new Error("Invalid OID", value);
-			}
-			return value;
-
-		case ObjectType.Counter:
-		case ObjectType.Counter64:
-			// Counters should be initialized to 0 (RFC2578, end of section 7.9)
-			// We'll do so.
-			return 0;
-
-		case ObjectType.IpAddress:
-			// A 32-bit internet address represented as OCTET STRING of length 4
-			var bytes = value.split(".");
-			if ( typeof value != "string" || bytes.length != 4 ) {
-				throw new Error("Invalid IpAddress", value);
-			}
-			return value;
-
-		default :
-			// Assume the caller knows what he's doing
-			return value;
-	}
-};
-
-
 Agent.prototype.tryCreateInstance = function (varbind, requestType) {
 	var row;
 	var column;
@@ -4841,7 +4909,7 @@ Agent.prototype.tryCreateInstance = function (varbind, requestType) {
 				}
 
 				// Ensure the value is of the correct type, and save it
-				value = this.castSetValue ( provider.scalarType, value );
+				value = ObjectTypeUtil.castSetValue ( provider.scalarType, value );
 				this.mib.setScalarValue ( provider.name, value );
 
 				// Now there should be an instanceNode available.
@@ -4901,7 +4969,7 @@ Agent.prototype.tryCreateInstance = function (varbind, requestType) {
 					}
 
 					// Map each column's value to the appropriate type
-					value = value.map( (v, i) => this.castSetValue ( provider.tableColumns[i].type, v ) );
+					value = value.map( (v, i) => ObjectTypeUtil.castSetValue ( provider.tableColumns[i].type, v ) );
 
 					// Add the table row
 					this.mib.addTableRow ( provider.name, value );
@@ -5078,7 +5146,7 @@ Agent.prototype.request = function (socket, requestMessage, rinfo) {
 					});
 				};
 
-				requestPdu.varbinds[i].requestValue = this.castSetValue (requestPdu.varbinds[i].type, requestPdu.varbinds[i].value);
+				requestPdu.varbinds[i].requestValue = ObjectTypeUtil.castSetValue (requestPdu.varbinds[i].type, requestPdu.varbinds[i].value);
 				switch ( requestPdu.varbinds[i].value ) {
 					case RowStatus["active"]:
 					case RowStatus["notInService"]:
@@ -5218,7 +5286,7 @@ Agent.prototype.request = function (socket, requestMessage, rinfo) {
 
 						} else {
 							// No special handling required. Just save the new value.
-							let setResult = mibRequests[savedIndex].instanceNode.setValue (me.castSetValue (
+							let setResult = mibRequests[savedIndex].instanceNode.setValue (ObjectTypeUtil.castSetValue (
 								requestPdu.varbinds[savedIndex].type,
 								requestPdu.varbinds[savedIndex].value
 							));
@@ -5254,9 +5322,9 @@ Agent.prototype.request = function (socket, requestMessage, rinfo) {
 					}
 					responseVarbind.requestType = requestPdu.varbinds[savedIndex].type;
 					if ( requestPdu.varbinds[savedIndex].requestValue ) {
-						responseVarbind.requestValue = me.castSetValue (requestPdu.varbinds[savedIndex].type, requestPdu.varbinds[savedIndex].requestValue);
+						responseVarbind.requestValue = ObjectTypeUtil.castSetValue (requestPdu.varbinds[savedIndex].type, requestPdu.varbinds[savedIndex].requestValue);
 					} else {
-						responseVarbind.requestValue = me.castSetValue (requestPdu.varbinds[savedIndex].type, requestPdu.varbinds[savedIndex].value);
+						responseVarbind.requestValue = ObjectTypeUtil.castSetValue (requestPdu.varbinds[savedIndex].type, requestPdu.varbinds[savedIndex].value);
 					}
 				}
 				if ( createResult[savedIndex] ) {
@@ -6425,5 +6493,6 @@ exports.ObjectParser = {
 	readUint32: readUint32,
 	readVarbindValue: readVarbindValue
 };
+exports.ObjectTypeUtil = ObjectTypeUtil;
 exports.Authentication = Authentication;
 exports.Encryption = Encryption;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "net-snmp",
-  "version": "3.15.2",
+  "version": "3.16.0",
   "description": "JavaScript implementation of the Simple Network Management Protocol (SNMP)",
   "main": "index.js",
   "directories": {
@@ -12,7 +12,8 @@
   },
   "devDependencies": {
     "eslint": "^9.9.1",
-    "getopts": "*"
+    "getopts": "^2.3.0",
+    "mocha": "^11.0.1"
   },
   "contributors": [
     {
@@ -47,6 +48,7 @@
   "author": "Mark Abrahams <mark@abrahams.co.nz>",
   "license": "MIT",
   "scripts": {
-    "lint": "./node_modules/.bin/eslint . ./**/*.js"
+    "lint": "eslint . ./**/*.js",
+    "test": "./node_modules/mocha/bin/mocha.js"
   }
 }

package/test/objects.js

@@ -0,0 +1,238 @@
+const assert = require('assert');
+const snmp   = require('../');
+
+describe('isValid() - Boolean', function() {
+	describe('JS true is a Boolean type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Boolean, true), true);
+		});
+	});
+	describe('JS false is a Boolean type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Boolean, false), true);
+		});
+	});
+});
+
+describe('isValid() - Integer', function() {
+	describe('Zero is an Integer type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, 0), true);
+		});
+	});
+	describe('An positive integer number is an Integer type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, 44), true);
+		});
+	});
+	describe('An positive integer string is an Integer type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, "44"), true);
+		});
+	});
+	describe('An negative integer number is an Integer type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, -24), true);
+		});
+	});
+	describe('A negative integer string is an Integer type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, "-24"), true);
+		});
+	});
+	describe('A non-integer decimal number is not an Integer type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, 45.2), false);
+		});
+	});
+	describe('A non-integer decimal string is not an Integer type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, "45.2"), false);
+		});
+	});
+	describe('An integer at the bottom of the valid range is an Integer type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, -2147483648), true);
+		});
+	});
+	describe('An integer just lower than the valid range is not an Integer type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, -2147483649), false);
+		});
+	});
+	describe('An integer at the top of the valid range is an Integer type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, 2147483647), true);
+		});
+	});
+	describe('An integer just higher than the valid range is not an Integer type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Integer, 2147483648), false);
+		});
+	});
+});
+
+describe('isValid() - OctetString', function() {
+	describe('A string is an OctetString type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.OctetString, 'Better late than never'), true);
+		});
+	});
+	describe('A buffer is an OctetString type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.OctetString, Buffer.from('1.3.6.1.2.3.4.5')), true);
+		});
+	});
+});
+
+describe('isValid() - OID', function() {
+	describe('A string OID is an OID type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.OctetString, '1.3.6.1.2.33.4.5'), true);
+		});
+	});
+	describe('A string non-OID is not an OID type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.OctetString, 'dog'), true);
+		});
+	});
+	describe('An OID string with a double-dot is not an OID type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.OctetString, '1.3.6.1..2.33.4.5'), true);
+		});
+	});
+	describe('An OID string with a leading dot is not an OID type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.OctetString, '.1.3.6.1..2.33.4.5'), true);
+		});
+	});
+	describe('An OID string with a trailing dot is not an OID type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.OctetString, '1.3.6.1.2.33.4.5.'), true);
+		});
+	});
+});
+
+describe('isValid() - Counter', function() {
+	describe('Zero is a Counter type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, 0), true);
+		});
+	});
+	describe('An positive integer number is a Counter type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, 44), true);
+		});
+	});
+	describe('An positive integer string is a Counter type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, "44"), true);
+		});
+	});
+	describe('An negative integer number is not a Counter type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, -24), false);
+		});
+	});
+	describe('A negative integer string is not a Counter type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, "-24"), false);
+		});
+	});
+	describe('A non-integer decimal number is not a Counter type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, 45.2), false);
+		});
+	});
+	describe('A non-integer decimal string is not a Counter type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, "45.2"), false);
+		});
+	});
+	describe('An integer at the bottom of the valid range is a Counter type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, 0), true);
+		});
+	});
+	describe('An integer just lower than the valid range is not a Counter type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, -1), false);
+		});
+	});
+	describe('An integer at the top of the valid range is a Counter type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, 4294967295), true);
+		});
+	});
+	describe('An integer just higher than the valid range is not a Counter type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter, 4294967296), false);
+		});
+	});
+});
+
+describe('isValid() - Counter64', function() {
+	describe('Zero is a Counter64 type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, 0), true);
+		});
+	});
+	describe('An positive integer number is a Counter64 type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, 44), true);
+		});
+	});
+	describe('An positive integer string is a Counter64 type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, "44"), true);
+		});
+	});
+	describe('An negative integer number is not a Counter64 type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, -24), false);
+		});
+	});
+	describe('A negative integer string is not a Counter64 type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, "-24"), false);
+		});
+	});
+	describe('A non-integer decimal number is not a Counter64 type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, 45.2), false);
+		});
+	});
+	describe('A non-integer decimal string is not a Counter64 type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, "45.2"), false);
+		});
+	});
+	describe('An integer at the bottom of the valid range is a Counter64 type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, 0), true);
+		});
+	});
+	describe('An integer just lower than the valid range is not a Counter64 type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.Counter64, -1), false);
+		});
+	});
+});
+
+describe('isValid() - IPAddress', function() {
+	describe('Dotted quad of numbers is an IpAddress type', function() {
+		it('returns true', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.IpAddress, '10.3.147.4'), true);
+		});
+	});
+	describe('Dotted quin of numbers is not an IpAddress type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.IpAddress, '10.3.147.22.4'), false);
+		});
+	});
+	describe('Dotted quad containing non-numbers is not an IpAddress type', function() {
+		it('returns false', function() {
+			assert.equal(snmp.ObjectTypeUtil.isValid(snmp.ObjectType.IpAddress, '10.word.147.4'), false);
+		});
+	});
+});