lazar 0.0.7 → 0.0.9

data/test/dataset.rb

@@ -8,10 +8,22 @@ class DatasetTest < MiniTest::Test
     d1 = Dataset.new 
     d1.save
     datasets = Dataset.all 
-    assert_equal Dataset, datasets.first.class
+    assert datasets.first.is_a?(Dataset), "#{datasets.first} is not a Dataset."
     d1.delete
   end
 
+  def test_create_without_features_smiles_and_inchi
+    ["smiles", "inchi"].each do |type|
+      d = Dataset.from_csv_file File.join(DATA_DIR,"batch_prediction_#{type}_small.csv")
+      assert_equal Dataset, d.class
+      refute_nil d.id
+      dataset = Dataset.find d.id
+      #p dataset.compounds
+      assert_equal 3, d.compounds.size.to_i
+      d.delete
+    end
+  end
+
   def test_create_empty
     d = Dataset.new
     assert_equal Dataset, d.class
@@ -57,19 +69,15 @@ class DatasetTest < MiniTest::Test
     assert_equal 3, d.compounds.size
     assert_equal 2, d.features.size
     assert_equal [[1,2],[4,5],[6,7]], d.data_entries
-    d.save_all
+    d.save
     # check if dataset has been saved correctly
     new_dataset = Dataset.find d.id
     assert_equal 3, new_dataset.compounds.size
     assert_equal 2, new_dataset.features.size
     assert_equal [[1,2],[4,5],[6,7]], new_dataset.data_entries
     d.delete
-    assert_raises Mongoid::Errors::DocumentNotFound do
-      Dataset.find d.id
-    end
-    assert_raises Mongoid::Errors::DocumentNotFound do
-      Dataset.find new_dataset.id
-    end
+    assert_nil Dataset.find d.id
+    assert_nil Dataset.find new_dataset.id
   end
 
   def test_dataset_accessors
@@ -78,7 +86,7 @@ class DatasetTest < MiniTest::Test
     new_dataset = Dataset.find d.id
     # get metadata
     assert_match "multicolumn.csv",  new_dataset.source
-    assert_equal "multicolumn.csv",  new_dataset.title
+    assert_equal "multicolumn",  new_dataset.name
     # get features
     assert_equal 6, new_dataset.features.size
     assert_equal 7, new_dataset.compounds.size
@@ -119,7 +127,7 @@ class DatasetTest < MiniTest::Test
     original_csv.shift
     csv.each_with_index do |row,i|
       compound = Compound.from_smiles row.shift
-      original_compound = Compound.from_smiles original_csv[i].shift
+      original_compound = Compound.from_smiles original_csv[i].shift.strip
       assert_equal original_compound.inchi, compound.inchi
       row.each_with_index do |v,j|
         if v.numeric?
@@ -161,7 +169,7 @@ class DatasetTest < MiniTest::Test
   def test_from_csv2
     File.open("#{DATA_DIR}/temp_test.csv", "w+") { |file| file.write("SMILES,Hamster\nCC=O,true\n ,true\nO=C(N),true") }
     dataset = Dataset.from_csv_file "#{DATA_DIR}/temp_test.csv"
-    assert_equal "Cannot parse SMILES compound ' ' at position 3, all entries are ignored.",  dataset.warnings.join
+    assert_equal "Cannot parse SMILES compound '' at position 3, all entries are ignored.",  dataset.warnings.join
     File.delete "#{DATA_DIR}/temp_test.csv"
     dataset.features.each{|f| feature = Feature.find f.id; feature.delete}
     dataset.delete
@@ -195,5 +203,17 @@ class DatasetTest < MiniTest::Test
     assert_equal 0.00323, d2.data_entries[5][0]
   end
 
+  def test_folds
+    dataset = Dataset.from_csv_file File.join(DATA_DIR,"loael.csv")
+    dataset.folds(10).each do |fold|
+      fold.each do |d|
+        assert_equal d.data_entries.size, d.compound_ids.size
+        assert_operator d.compound_ids.size, :>=, d.compound_ids.uniq.size
+      end
+      assert_operator fold[0].compound_ids.uniq.size, :>=, fold[1].compound_ids.uniq.size
+    end
+    #puts dataset.folds 10
+  end
+
 end
 

data/test/default_environment.rb

@@ -0,0 +1,11 @@
+require 'minitest/autorun'
+require_relative '../lib/lazar.rb'
+include OpenTox
+class DefaultEnvironmentTest < MiniTest::Test
+  def test_lazar_environment
+    assert_equal "production", ENV["LAZAR_ENV"]
+    assert_equal "production", ENV["MONGOID_ENV"]
+    assert_equal "production", ENV["RACK_ENV"]
+    assert_equal "production", Mongoid.clients["default"]["database"]
+  end
+end

data/test/descriptor.rb

@@ -4,80 +4,65 @@ class DescriptorTest < MiniTest::Test
 
   def test_list
     # check available descriptors
-    @descriptors = OpenTox::Algorithm::Descriptor::DESCRIPTORS.keys
-    assert_equal 111,@descriptors.size,"wrong num physchem descriptors"
-    @descriptor_values = OpenTox::Algorithm::Descriptor::DESCRIPTOR_VALUES
-    assert_equal 356,@descriptor_values.size,"wrong num physchem descriptors"
-    sum = 0
-    [ @descriptors, @descriptor_values ].each do |desc|
-      {"Openbabel"=>16,"Cdk"=>(desc==@descriptors ? 50 : 295),"Joelib"=>45}.each do |k,v|
-        assert_equal v,desc.select{|x| x=~/^#{k}\./}.size,"wrong num #{k} descriptors"
-        sum += v
-      end
-    end
-    assert_equal (111+356),sum
+    assert_equal 355,PhysChem.descriptors.size,"incorrect number of physchem descriptors"
+    assert_equal 15,PhysChem.openbabel_descriptors.size,"incorrect number of Openbabel descriptors"
+    assert_equal 295,PhysChem.cdk_descriptors.size,"incorrect number of Cdk descriptors"
+    assert_equal 45,PhysChem.joelib_descriptors.size,"incorrect number of Joelib descriptors"
   end
 
   def test_smarts
     c = OpenTox::Compound.from_smiles "N=C=C1CCC(=F=FO)C1"
     File.open("tmp.png","w+"){|f| f.puts c.png}
     s = Smarts.find_or_create_by(:smarts => "F=F")
-    result = OpenTox::Algorithm::Descriptor.smarts_match c, s
+    result = c.smarts_match [s]
     assert_equal [1], result
     smarts = ["CC", "C", "C=C", "CO", "F=F", "C1CCCC1", "NN"].collect{|s| Smarts.find_or_create_by(:smarts => s)}
-    result = OpenTox::Algorithm::Descriptor.smarts_match c, smarts
+    result = c.smarts_match smarts
     assert_equal [1, 1, 1, 0, 1, 1, 0], result
     smarts_count = [10, 6, 2, 0, 2, 10, 0]
-    result = OpenTox::Algorithm::Descriptor.smarts_count c, smarts
+    result = c.smarts_match smarts, true
     assert_equal smarts_count, result
   end
 
   def test_compound_openbabel_single
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = OpenTox::Algorithm::Descriptor.physchem c, ["Openbabel.logP"]
-    assert_equal 1.12518, result.first
+    result = c.physchem [PhysChem.find_or_create_by(:name => "Openbabel.logP")]
+    assert_equal 1.12518, result.first.last.round(5)
   end
 
   def test_compound_cdk_single
     c = OpenTox::Compound.from_smiles "c1ccccc1"
-    result = OpenTox::Algorithm::Descriptor.physchem c, ["Cdk.AtomCount"]
-    assert_equal [12], result
+    result = c.physchem [PhysChem.find_or_create_by(:name => "Cdk.AtomCount.nAtom")]
+    assert_equal 12, result.first.last
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = OpenTox::Algorithm::Descriptor.physchem c, ["Cdk.AtomCount"]
-    assert_equal [17], result
-    result = OpenTox::Algorithm::Descriptor.physchem c, ["Cdk.CarbonTypes"]
+    result = c.physchem [PhysChem.find_or_create_by(:name => "Cdk.AtomCount.nAtom")]
+    assert_equal 17, result.first.last
     c_types = {"Cdk.CarbonTypes.C1SP1"=>1, "Cdk.CarbonTypes.C2SP1"=>0, "Cdk.CarbonTypes.C1SP2"=>0, "Cdk.CarbonTypes.C2SP2"=>1, "Cdk.CarbonTypes.C3SP2"=>0, "Cdk.CarbonTypes.C1SP3"=>2, "Cdk.CarbonTypes.C2SP3"=>1, "Cdk.CarbonTypes.C3SP3"=>1, "Cdk.CarbonTypes.C4SP3"=>0}
-    assert_equal [1, 0, 0, 1, 0, 2, 1, 1, 0], result
+    physchem_features = c_types.collect{|t,nr| PhysChem.find_or_create_by(:name => t)}
+    result = c.physchem physchem_features
+    assert_equal [1, 0, 0, 1, 0, 2, 1, 1, 0], result.values
   end
 
   def test_compound_joelib_single
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = OpenTox::Algorithm::Descriptor.physchem c, ["Joelib.LogP"]
-    assert_equal [2.65908], result
+    result = c.physchem [PhysChem.find_or_create_by(:name => "Joelib.LogP")]
+    assert_equal 2.65908, result.first.last
   end
 
   def test_compound_all
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = OpenTox::Algorithm::Descriptor.physchem c
-    assert_equal 332, result.size
-    assert_equal 30.8723, result[2]
-    assert_equal 1.12518, result[328]
+    result = c.physchem PhysChem.descriptors
+    amr = PhysChem.find_or_create_by(:name => "Cdk.ALOGP.AMR", :library => "Cdk")
+    sbonds = PhysChem.find_by(:name => "Openbabel.sbonds")
+    assert_equal 30.8723, result[amr.id.to_s]
+    assert_equal 5, result[sbonds.id.to_s]
   end
 
   def test_compound_descriptor_parameters
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = OpenTox::Algorithm::Descriptor.physchem c, [ "Openbabel.logP", "Cdk.AtomCount", "Cdk.CarbonTypes", "Joelib.LogP" ]#, true
-    assert_equal 12, result.size
-    assert_equal [1.12518, 17.0, 1, 0, 0, 1, 0, 2, 1, 1, 0, 2.65908], result#.last
-  end
-
-  def test_dataset_descriptor_parameters
-    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.mini.csv")
-    d = OpenTox::Algorithm::Descriptor.physchem dataset, [ "Openbabel.logP", "Cdk.AtomCount", "Cdk.CarbonTypes", "Joelib.LogP" ]
-    assert_kind_of Dataset, d
-    assert_equal dataset.compounds, d.compounds
-    assert_equal dataset.compounds.size, d.data_entries.size
-    assert_equal 12, d.data_entries.first.size
+    result = c.physchem [ "Openbabel.logP", "Cdk.AtomCount.nAtom", "Joelib.LogP" ].collect{|d| PhysChem.find_or_create_by(:name => d)}
+    assert_equal 3, result.size
+    assert_equal [1.12518, 17.0, 2.65908], result.values.collect{|v| v.round 5}
   end
 
 end

data/test/error.rb

@@ -4,9 +4,7 @@ class ErrorTest < MiniTest::Test
 
   def test_bad_request
     object = OpenTox::Feature.new 
-    assert_raises Mongoid::Errors::DocumentNotFound do
-      response = OpenTox::Feature.find(object.id)
-    end
+    assert_nil OpenTox::Feature.find(object.id)
   end
 
   def test_error_methods

data/test/experiment.rb

@@ -0,0 +1,301 @@
+require_relative "setup.rb"
+
+class ExperimentTest < MiniTest::Test
+
+  def test_regression_experiment
+    skip
+    datasets = [
+      "EPAFHM.medi.csv",
+      #"EPAFHM.csv",
+      #"FDA_v3b_Maximum_Recommended_Daily_Dose_mmol.csv",
+      "LOAEL_mmol_corrected_smiles.csv"
+    ]
+    experiment = Experiment.create(
+      :name => "Default regression for datasets #{datasets}.",
+      :dataset_ids => datasets.collect{|d| Dataset.from_csv_file(File.join(DATA_DIR, d)).id},
+      :model_settings => [
+        {
+          :algorithm => "OpenTox::Model::LazarRegression",
+        }
+      ]
+    )
+    #experiment.run
+    puts experiment.report.to_yaml
+    assert_equal datasets.size, experiment.results.size
+    experiment.results.each do |dataset_id, result|
+      assert_equal 1, result.size
+      result.each do |r|
+        assert_kind_of BSON::ObjectId, r[:model_id]
+        assert_kind_of BSON::ObjectId, r[:repeated_crossvalidation_id]
+      end
+    end
+  end
+
+  def test_classification_experiment
+
+    skip
+    datasets = [ "hamster_carcinogenicity.csv" ]
+    experiment = Experiment.create(
+      :name => "Fminer vs fingerprint classification for datasets #{datasets}.",
+      :dataset_ids => datasets.collect{|d| Dataset.from_csv_file(File.join(DATA_DIR, d)).id},
+      :model_settings => [
+        {
+          :algorithm => "OpenTox::Model::LazarClassification",
+        },{
+          :algorithm => "OpenTox::Model::LazarClassification",
+          :neighbor_algorithm_parameter => {:min_sim => 0.3}
+        },
+        #{
+          #:algorithm => "OpenTox::Model::LazarFminerClassification",
+        #}
+      ]
+    )
+    #experiment.run
+=begin
+    experiment = Experiment.find "55f944a22b72ed7de2000000"
+=end
+    puts experiment.report.to_yaml
+    experiment.results.each do |dataset_id, result|
+      assert_equal 2, result.size
+      result.each do |r|
+        assert_kind_of BSON::ObjectId, r[:model_id]
+        assert_kind_of BSON::ObjectId, r[:repeated_crossvalidation_id]
+      end
+    end
+  end
+
+  def test_regression_fingerprints
+    skip
+#=begin
+    datasets = [
+      "EPAFHM.medi.csv",
+      #"LOAEL_mmol_corrected_smiles.csv"
+    ]
+    min_sims = [0.3,0.7]
+    #min_sims = [0.7]
+    #types = ["FP2","FP3","FP4","MACCS","MP2D"]
+    types = ["MP2D","FP3"]
+    experiment = Experiment.create(
+      :name => "Fingerprint regression with different types for datasets #{datasets}.",
+      :dataset_ids => datasets.collect{|d| Dataset.from_csv_file(File.join(DATA_DIR, d)).id},
+    )
+    types.each do |type|
+      min_sims.each do |min_sim|
+        experiment.model_settings << {
+          :model_algorithm => "OpenTox::Model::LazarRegression",
+          :prediction_algorithm => "OpenTox::Algorithm::Regression.weighted_average",
+          :neighbor_algorithm => "fingerprint_neighbors",
+          :neighbor_algorithm_parameters => {
+            :type => type,
+            :min_sim => min_sim,
+          }
+        }
+      end
+    end
+    experiment.run
+#=end
+=begin
+    experiment = Experiment.find '56029cb92b72ed673d000000'
+=end
+    p experiment.id
+    experiment.results.each do |dataset,result|
+      result.each do |r|
+        params = Model::Lazar.find(r["model_id"])[:neighbor_algorithm_parameters]
+        RepeatedCrossValidation.find(r["repeated_crossvalidation_id"]).crossvalidations.each do |cv|
+          cv.validation_ids.each do |vid|
+            model_params = Model::Lazar.find(Validation.find(vid).model_id)[:neighbor_algorithm_parameters]
+            assert_equal params[:type], model_params[:type]
+            assert_equal params[:min_sim], model_params[:min_sim]
+            refute_equal params[:training_dataset_id], model_params[:training_dataset_id]
+          end
+        end
+      end
+    end
+    puts experiment.report.to_yaml
+    p experiment.summary
+  end
+
+  def test_mpd_fingerprints
+    skip
+    datasets = [
+      "EPAFHM.medi.csv",
+    ]
+    types = ["FP2","MP2D"]
+    experiment = Experiment.create(
+      :name => "FP2 vs MP2D fingerprint regression for datasets #{datasets}.",
+      :dataset_ids => datasets.collect{|d| Dataset.from_csv_file(File.join(DATA_DIR, d)).id},
+    )
+    types.each do |type|
+    experiment.model_settings << {
+      :algorithm => "OpenTox::Model::LazarRegression",
+      :neighbor_algorithm => "fingerprint_neighbors",
+      :neighbor_algorithm_parameter => {
+        :type => type,
+        :min_sim => 0.7,
+      }
+    }
+    end
+    experiment.run
+    p experiment.id
+=begin
+=end
+    #experiment = Experiment.find '55ffd0c02b72ed123c000000'
+    p experiment
+    puts experiment.report.to_yaml
+  end
+
+  def test_multiple_datasets
+    skip
+    datasets = [
+      "EPAFHM.medi.csv",
+      "LOAEL_mmol_corrected_smiles.csv"
+    ]
+    min_sims = [0.3]
+    types = ["FP2"]
+    experiment = Experiment.create(
+      :name => "Fingerprint regression with mutiple datasets #{datasets}.",
+      :dataset_ids => datasets.collect{|d| Dataset.from_csv_file(File.join(DATA_DIR, d)).id},
+    )
+    types.each do |type|
+      min_sims.each do |min_sim|
+        experiment.model_settings << {
+          :model_algorithm => "OpenTox::Model::LazarRegression",
+          :prediction_algorithm => "OpenTox::Algorithm::Regression.weighted_average",
+          :neighbor_algorithm => "fingerprint_neighbors",
+          :neighbor_algorithm_parameters => {
+            :type => type,
+            :min_sim => min_sim,
+          }
+        }
+      end
+    end
+    experiment.run
+    p experiment.id
+    experiment.results.each do |dataset,result|
+      result.each do |r|
+        params = Model::Lazar.find(r["model_id"])[:neighbor_algorithm_parameters]
+        RepeatedCrossValidation.find(r["repeated_crossvalidation_id"]).crossvalidations.each do |cv|
+          cv.validation_ids.each do |vid|
+            model_params = Model::Lazar.find(Validation.find(vid).model_id)[:neighbor_algorithm_parameters]
+            assert_equal params[:type], model_params[:type]
+            assert_equal params[:min_sim], model_params[:min_sim]
+            refute_equal params[:training_dataset_id], model_params[:training_dataset_id]
+          end
+        end
+      end
+    end
+    puts experiment.report.to_yaml
+    p experiment.summary
+  end
+
+  def test_mpd_mna_regression_fingerprints
+    skip
+    datasets = [
+      "EPAFHM.medi.csv",
+      #"hamster_carcinogenicity.csv" 
+    ]
+    min_sims = [0.0,0.3]
+    types = ["MP2D","MNA"]
+    neighbor_algos = [
+      "fingerprint_neighbors",
+      "fingerprint_count_neighbors",
+    ]
+    experiment = Experiment.create(
+      :name => "MNA vs MPD descriptors",
+      :dataset_ids => datasets.collect{|d| Dataset.from_csv_file(File.join(DATA_DIR, d)).id},
+    )
+    types.each do |type|
+      min_sims.each do |min_sim|
+        neighbor_algos.each do |neighbor_algo|
+          experiment.model_settings << {
+            :model_algorithm => "OpenTox::Model::LazarRegression",
+            :prediction_algorithm => "OpenTox::Algorithm::Regression.weighted_average",
+            :neighbor_algorithm => neighbor_algo,
+            :neighbor_algorithm_parameters => {
+              :type => type,
+              :min_sim => min_sim,
+            }
+          }
+        end
+      end
+    end
+    experiment.run
+#=end
+=begin
+    experiment = Experiment.find '56029cb92b72ed673d000000'
+=end
+    p experiment.id
+    puts experiment.report.to_yaml
+    #p experiment.summary
+    experiment.results.each do |dataset,result|
+      result.each do |r|
+        p r
+        # TODO fix r["model_id"]
+        params = Model::Lazar.find(r["model_id"])[:neighbor_algorithm_parameters]
+        RepeatedCrossValidation.find(r["repeated_crossvalidation_id"]).crossvalidations.each do |cv|
+          cv.validation_ids.each do |vid|
+            model_params = Model::Lazar.find(Validation.find(vid).model_id)[:neighbor_algorithm_parameters]
+            assert_equal params[:type], model_params[:type]
+            assert_equal params[:min_sim], model_params[:min_sim]
+            refute_equal params[:training_dataset_id], model_params[:training_dataset_id]
+          end
+        end
+      end
+    end
+  end
+
+  def test_mpd_mna_classification_fingerprints
+    skip
+    datasets = [
+      #"EPAFHM.medi.csv",
+      "hamster_carcinogenicity.csv" 
+    ]
+    min_sims = [0.0,0.3]
+    types = ["MP2D","MNA"]
+    neighbor_algos = [
+      "fingerprint_count_neighbors",
+      "fingerprint_neighbors",
+    ]
+    experiment = Experiment.create(
+      :name => "MNA vs MPD descriptors",
+      :dataset_ids => datasets.collect{|d| Dataset.from_csv_file(File.join(DATA_DIR, d)).id},
+    )
+    types.each do |type|
+      min_sims.each do |min_sim|
+        neighbor_algos.each do |neighbor_algo|
+          experiment.model_settings << {
+            :model_algorithm => "OpenTox::Model::LazarClassification",
+            :prediction_algorithm => "OpenTox::Algorithm::Classification.weighted_majority_vote",
+            :neighbor_algorithm => neighbor_algo,
+            :neighbor_algorithm_parameters => {
+              :type => type,
+              :min_sim => min_sim,
+            }
+          }
+        end
+      end
+    end
+    experiment.run
+#=end
+=begin
+    experiment = Experiment.find '56029cb92b72ed673d000000'
+=end
+    p experiment.id
+    puts experiment.report.to_yaml
+    #p experiment.summary
+    experiment.results.each do |dataset,result|
+      result.each do |r|
+        # TODO fix r["model_id"]
+        params = Model::Lazar.find(r["model_id"])[:neighbor_algorithm_parameters]
+        RepeatedCrossValidation.find(r["repeated_crossvalidation_id"]).crossvalidations.each do |cv|
+          cv.validation_ids.each do |vid|
+            model_params = Model::Lazar.find(Validation.find(vid).model_id)[:neighbor_algorithm_parameters]
+            assert_equal params[:type], model_params[:type]
+            assert_equal params[:min_sim], model_params[:min_sim]
+            refute_equal params[:training_dataset_id], model_params[:training_dataset_id]
+          end
+        end
+      end
+    end
+  end
+end

data/test/feature.rb

@@ -26,16 +26,13 @@ class FeatureTest < MiniTest::Test
 
     id = @feature2.id
     @feature2.delete
-    assert_raises Mongoid::Errors::DocumentNotFound do
-      OpenTox::Feature.find(id)
-    end
+    assert_nil OpenTox::Feature.find(id)
   end
 
   def test_duplicated_features
     metadata = {
       :name => "feature duplication test",
       :nominal => true,
-      :description => "feature duplication test"
     }
     feature = NumericBioAssay.find_or_create_by metadata
     dup_feature = NumericBioAssay.find_or_create_by metadata
@@ -44,12 +41,8 @@ class FeatureTest < MiniTest::Test
     assert !feature.id.nil?, "No Feature ID in #{dup_feature.inspect}"
     assert_equal feature.id, dup_feature.id
     feature.delete
-    assert_raises Mongoid::Errors::DocumentNotFound do
-      OpenTox::Feature.find(feature.id)
-    end
-    assert_raises Mongoid::Errors::DocumentNotFound do
-      OpenTox::Feature.find(dup_feature.id)
-    end
+    assert_nil OpenTox::Feature.find(feature.id)
+    assert_nil OpenTox::Feature.find(dup_feature.id)
   end
 
   def test_smarts_feature
@@ -62,4 +55,23 @@ class FeatureTest < MiniTest::Test
     assert original.smarts, "CN"
   end
 
+  def test_physchem_description
+    assert_equal 355, PhysChem.descriptors.size
+    assert_equal 15, PhysChem.openbabel_descriptors.size
+    assert_equal 295, PhysChem.cdk_descriptors.size
+    assert_equal 45, PhysChem.joelib_descriptors.size
+    assert_equal 310, PhysChem.unique_descriptors.size
+  end
+
+  def test_physchem
+    assert_equal 355, PhysChem.descriptors.size
+    c = Compound.from_smiles "CC(=O)CC(C)C"
+    logP = PhysChem.find_or_create_by :name => "Openbabel.logP"
+    assert_equal 1.6215, logP.calculate(c)
+    jlogP = PhysChem.find_or_create_by :name => "Joelib.LogP"
+    assert_equal 3.5951, jlogP.calculate(c)
+    alogP = PhysChem.find_or_create_by :name => "Cdk.ALOGP.ALogP"
+    assert_equal 0.35380000000000034, alogP.calculate(c)
+  end
+
 end