http://www.connectionstrings.com/?carrier=mysql

Set Cnn = Server.CreateObject("ADODB.Connection")
Cnn.open "DRIVER={Microsoft Access Driver (*.mdb)};DBQ=c:\mydatabase.mdb"

Set Cnn = Server.CreateObject("ADODB.Connection")
Cnn.open "PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=c:\mydatabase.mdb"

Set Cnn = Server.CreateObject("ADODB.Connection")
Cnn.open "FILEDSN=ADSN"

Set Conn = Server.CreateObject("ADODB.Connection")
Conn.open "DSNname" 

Set Conn = Server.CreateObject("ADODB.Connection")
Conn.open "DSNname","username","password" 

Set Conn = Server.CreateObject("ADODB.Connection")
DSNtest="DRIVER={Microsoft Access Driver (*.mdb)}; "
DSNtest=dsntest & "DBQ=c:\mydatabase.mdb"
Conn.Open DSNtest

Set Conn = Server.CreateObject("ADODB.Connection")
DSNtest="DRIVER={Microsoft Access Driver (*.mdb)}; "
DSNtest=dsntest & "DBQ=" & 
Server.MapPath("/databases/mydatabase.mdb")
Conn.Open DSNtest

Set cnn = Server.CreateObject("ADODB.Connection")

cnn.open "PROVIDER=SQLOLEDB;DATA SOURCE=sqlservername;UID=username;PWD=password;DATABASE=mydatabase "

Set Conn = Server.CreateObject("ADODB.Connection")
Conn.open "DSN=MyDSN;UID=user;PWD=password;DATABASE=mydatabase"

Set Conn = Server.CreateObject("ADODB.Connection")
DSNtest="DRIVER={SQL 
Server};SERVER=ServerName;UID=USER;PWD=password;DATABASE=mydatabase"
Conn.open DSNtest

<%

Set Conn = Server.CreateObject("ADODB.Connection")

ConnStr= "Driver=Microsoft Visual Foxpro Driver; UID=userID;SourceType=DBC;SourceDB=C:\databases\mydatabase.dbc"

Conn.Open ConnStr

%>

Set Conn = Server.CreateObject("ADODB.Connection")
Conn.cursorlocation=adUseClient
' requires use of adovbs.inc; numeric value is 3
Conn.open "DSN=test;UID=name;PWD=pass"

Set Conn = Server.CreateObject("ADODB.Connection")
Conn.cursorlocation=adUseClient
' requires use of adovbs.inc; numeric value is 3
DSNTest="Provider=MSDAORA.1;Password=pass;User ID=name;Data 
Source=data.world"
Conn.open DSNtest

1. Facade 패턴
2. Adapter 패턴
3. Bridge 패턴
4. Abstract Factory 패턴
5. Strategy 패턴
6. Decorate 패턴

require 'test/unit'
class JollyJumper

  attr_reader :values

  

  def initialize

    @values = []

  end

  

  def insert_value(value)

    @values << value

  end

  

  def print_values

    @values.each{ |value| print value.to_s + ' ' }

  end

  

  def calculate

    result = true

    @values.each_index do |index| 

      first_value = (@values[index -1] - @values[index]).abs if @values[index-1] != nil

      second_value = (@values[index +1] - @values[index]).abs if @values[index+1] != nil    

      result &= values.member?(first_value) if first_value != nil

      result &= values.member?(second_value) if second_value != nil

    end

    result

  end  

end
class JollyJumperTest < Test::Unit::TestCase

  def test_case1

    jumper = JollyJumper.new

    assert_not_equal(nil, jumper)

    jumper.insert_value(4)

    jumper.insert_value(1)

    jumper.insert_value(4)

    jumper.insert_value(2)

    jumper.insert_value(3)    

    jumper.print_values()

    assert_equal(true, jumper.calculate)

  end

  

  def test_case2

    jumper = JollyJumper.new

    assert_not_equal(nil, jumper)

    jumper.insert_value(5)

    jumper.insert_value(1)

    jumper.insert_value(4)

    jumper.insert_value(2)

    jumper.insert_value(-1)    

    jumper.insert_value(6)    

    jumper.print_values()

    assert_equal(false, jumper.calculate)

  end

  

end

import unittest

import os

import math
segment_enables = [

[True, True, True, False, True, True, True],

[False, False, True, False, False, True, False],

[True, False, True, True, True, False, True],

[True, False, True, True, False, True, True],

[False, True, True, True, False, True, False],

[True, True, False, True, False, True, True],

[False, True, False, True, True, True, True],

[True, True, True, False, False, True, True],

[True, True, True, True, True, True, True],

[True, True, True, True, False, True, True]

]


class SevenSegmentNumber:

    def __init__(self, number, size):

        self.size = size

        self.number = number

        self.max_line = size * 2 + 3

     

    def printHorizontalLine(self, print_enable):

        lines = ' '

        for i in range(self.size):

            if print_enable:

                lines = lines + '-'

            else:

                lines = lines + ' '

        lines = lines + ' '

        return lines

    

    def printVerticalLine(self, print_first, print_last):

        lines = ''

        vert_size = self.size  + 2 

        if print_first:

            lines = lines + '|'

        else:

            lines = lines + ' '

        

        for i in range(vert_size - 2):

            lines = lines + ' '
        if print_last:

             lines = lines + '|'

        else:

             lines = lines + ' '        

        return lines   

    

    

    def getLine(self, line):

        total_line = self.size * 2 + 3

        line_segment = (total_line - 3) / 2 + 1

        line_end = total_line - 1        

        out_line = ''       

        if line == 0:

            out_line = self.printHorizontalLine(segment_enables[self.number][0])

        elif 0 < line and line < line_segment:

            out_line = self.printVerticalLine(segment_enables[self.number][1], segment_enables[self.number][2])

        elif line == line_segment:

            out_line = self.printHorizontalLine(segment_enables[self.number][3])

        elif line_segment < line and line < line_end:

            out_line = self.printVerticalLine(segment_enables[self.number][4], segment_enables[self.number][5])

        elif line == line_end:

            out_line = self.printHorizontalLine(segment_enables[self.number][6])

        return out_line
class Numbers:    

    def __init__(self):

        self.numbers = []

        self.seven_segments = []
    def displayNumber(self, number, size):

        decimal = int(math.log(number) / math.log(10)) + 1

        self.numbers = []

        self.seven_segments = []

        

        for i in range(decimal):

            self.numbers.append(int(str(number)[i]))

            segment = SevenSegmentNumber(self.numbers[i], size)

            self.seven_segments.append(segment)

        

        max_line = self.seven_segments[0].max_line

        for i in range(max_line):

            line = ''

            for s in range(decimal):

                line = line + self.seven_segments[s].getLine(i) + ' '

            print line

        
class SevenSegmentNumberTest(unittest.TestCase):

    """

    def testDisplay(self):

        print 'Start'

        zero = SevenSegmentNumber(8, 3)

        

        for i in range(zero.max_line):

            print zero.getLine(i),

            print ""

    """

    def testNumber1(self):

        number = SevenSegmentNumber(8, 2)

        #print number.getLine(0)

        #self.assertEqual(number.max_line, 3 + 2 * 2)

        #self.assertEqual('    ', number.getLine(0))

        #self.assertEqual('   |', number.getLine(1))

        

        #for i in range(0, number.max_line):

        #    print number.getLine(i)

    

    def testOutputNumber(self):

        for i in range(10):

            number = SevenSegmentNumber(i, 2)

            for j in range(number.max_line):

                print number.getLine(j)

       

if __name__ == '__main__':

    #unittest.main()

    n = Numbers()

    n.displayNumber(1238, 3)

require 'test/unit'
class SevenSegment

    attr_reader :number, :size, :height, :width

    attr_writer :number, :size 

    

    @@segment_enables = [ 

            [true, true, true, false, true, true, true],

            [false, false, true, false, false, true, false],

            [true, false, true, true, true, false, true],

            [true, false, true, true, false, true, true],

            [false, true, true, true, false, true, false],

            [true, true, false, true, false, true, true],

            [false, true, false, true, true, true, true],

            [true, true, true, false, false, true, false],

            [true, true, true, true, true, true, true],

            [true, true, true, true, false, true, true] ]

    

    def initialize(number, size)

        @number = number

        @size = size

        @height = size * 2 + 3

        @width = size + 2

    end

    

    def get_vertical_line(mark_first, mark_second)

        line = ''

        length = @size + 2

         

        line = line + '|' if mark_first

        line = line + ' ' if !mark_first
        @size.times { line = line + ' ' }

        

        line = line + '|' if mark_second

        line = line + ' ' if !mark_second

        line        

    end

    

    def get_horizontal_line(enable)        

        mark = ''

        mark = '-' if enable

        mark = ' ' if !enable

        length = self.size + 2
        line = ' '

        @size.times { line = line + mark }

        line = line + ' '

        line

    end

     

    def get_line(line_count)

        if line_count == 0 then self.get_horizontal_line(@@segment_enables[@number][0])

        elsif line_count > 0 and line_count < (@size+1) then self.get_vertical_line(@@segment_enables[@number][1], @@segment_enables[@number][2])

        elsif line_count == (@size+1) then self.get_horizontal_line(@@segment_enables[@number][3])

        elsif line_count > (@size+1) and line_count < (@size * 2 + 2) then self.get_vertical_line(@@segment_enables[@number][4], @@segment_enables[@number][5])            

        elsif line_count == (@size * 2 + 2) then self.get_horizontal_line(@@segment_enables[@number][6])                    

        end

    end    

end
class SevenSegments

    attr_reader :numbers, :size

    attr_writer :numbers, :size

    

    def initialize(size, number)

        @size = size

        self.set_number(number)

    end
    def set_number(number)

        @numbers = []

        string_numbers = number.to_s()

        string_numbers.length.times { |index| @numbers << string_numbers[index] - 48 }

    end
    def display_number

        puts ' ' 

        seven_segments = []

        @numbers.each { |n| seven_segments << SevenSegment.new(n, @size) }

        line = @size * 2 + 3
        line.times do |line_count| 

            line = ''

            seven_segments.each do |seven_segment|

                line = line + seven_segment.get_line(line_count) + ' '

            end

            puts line 

        end

        

    end

end
class SevenSegmentsTest < Test::Unit::TestCase

    def test_numbers

        s = SevenSegments.new(3, 987654321)

        print s.numbers[0]        

        s.display_number

        assert_equal(9, s.numbers[0])

    end

end
class SevenSegmentTest < Test::Unit::TestCase

    def test_number0

        s = SevenSegment.new(0,2)

        assert_equal(" -- ", s.get_line(0))

        assert_equal("|  |", s.get_line(1))

        assert_equal("|  |", s.get_line(2))

        assert_equal("    ", s.get_line(3))

        assert_equal("|  |", s.get_line(4))

        assert_equal("|  |", s.get_line(5))

        assert_equal(" -- ", s.get_line(6))

    end
    def test_number1

        s = SevenSegment.new(1,2)

        assert_equal("    ", s.get_line(0))

        assert_equal("   |", s.get_line(1))

        assert_equal("   |", s.get_line(2))

        assert_equal("    ", s.get_line(3))

        assert_equal("   |", s.get_line(4))

        assert_equal("   |", s.get_line(5))

        assert_equal("    ", s.get_line(6))

    end

     

    def test_number8

        s = SevenSegment.new(8,2)

        assert_equal(" -- ", s.get_line(0))

        assert_equal("|  |", s.get_line(1))

        assert_equal("|  |", s.get_line(2))

        assert_equal(" -- ", s.get_line(3))

        assert_equal("|  |", s.get_line(4))

        assert_equal("|  |", s.get_line(5))

        assert_equal(" -- ", s.get_line(6))

        

    end

end

import unittest

class TheTrip:
    def __init__(self, count):
        self.count = count
        self.costs = []
        pass
    def inputCost(self, cost):
        self.costs.append( float(cost * 100) )
    def calculateAverageCost(self):
        return float( sum(self.costs) / len(self.costs) ) / 100.00
    def calculateMinCharge(self):
        average = self.calculateAverageCost() * 100.00
        diff_values = []
        for value in self.costs:
            differ = average - value
            diff_values.append(abs(differ))
        return sum(diff_values) / 2.00 / 100.00

class TheTripTest(unittest.TestCase):
    def setUp(self):
        pass
    def testInsertValue(self):
        t = TheTrip(3)
        t.inputCost(10.00)
        t.inputCost(20.00)
        t.inputCost(30.00)
        self.assertEqual(20.00, t.calculateAverageCost())
        self.assertEqual(10.00, t.calculateMinCharge())
    def testInsertValue2(self):
        t = TheTrip(4)
        t.inputCost(15.00)
        t.inputCost(15.01)
        t.inputCost(3.00)
        t.inputCost(3.01)
        self.assertEqual(11.99, t.calculateMinCharge())
if __name__ == '__main__':
    unittest.main()

require 'test/unit'

class TheTrip
attr_reader :member, :costs, :average
attr_writer :member, :costs

    def initialize(number)
        self.member = number
        self.costs = []
    end

    def input_cost(cost)
        self.costs << cost
        @average = 0
        self.costs.each {|value| @average += value }
        @average /= self.costs.length
    end

    def get_min_charge()
        charges = 0.00
        self.costs.each { |value| charges += (value - self.average).abs }
        return charges / 2.00
    end
    
end

class TheTripTest < Test::Unit::TestCase
    def test_case1
        t = TheTrip.new(3)
        t.input_cost(10.00)
        t.input_cost(20.00)
        t.input_cost(30.00)
        assert_equal(20.00, t.average)
        assert_equal(10.00, t.get_min_charge())
    end

    def test_case2
        t = TheTrip.new(4)
        t.input_cost(15.00)
        t.input_cost(15.01)
        t.input_cost(3.00)
        t.input_cost(3.01)
        assert_equal(11.99, t.get_min_charge())
    end
end

Python

import sys
import unittest

class ThreePlusOne:
    def __init__(self):
        pass
    
    def getArray(self, number):
        return self.__calculateValues(number)

    def __calculateValues(self, number):
        current_value = number
        calculated_values = []
        calculated_values.append(current_value)
        
        while current_value != 1:
            if (current_value % 2) == 0:
                current_value = current_value / 2
            else:
                current_value = current_value * 3 + 1
            calculated_values.append(current_value)

        return calculated_values

    def getLength(self, number):
        return len(self.__calculateValues(number))
    
    def getMaxLengthWithRange(self, start_number, end_number):
        max_length = 0
        for current_number in range(start_number, end_number):
            length = self.getLength(current_number)
            if length > max_length:
                max_length = length
        return max_length
        
    def displayResult(self, start_number, end_number):
        max_length = self.getMaxLengthWithRange(start_number, end_number)
        print '%d %d %d' % (start_number, end_number, max_length)

class ThreePlusOneTest(unittest.TestCase):
    def setUp(self):
        pass

    def testCheckValue(self):
        correct_values = [22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
        t = ThreePlusOne()
        make_values = t.getArray(22)

        self.assertEqual(make_values, correct_values)
        
    def testCheckSize(self):
        correct_value = 16
        t = ThreePlusOne()
        make_value = t.getLength(22)
        self.assertEqual(make_value, correct_value)
    
    def testCheckRange(self):
        t = ThreePlusOne()
        
        result = t.getMaxLengthWithRange(1, 10)
        self.assertEqual(result, 20)
        
        result = t.getMaxLengthWithRange(100, 200)
        self.assertEqual(result, 125)

        result = t.getMaxLengthWithRange(201, 210)
        self.assertEqual(result, 89)

        result = t.getMaxLengthWithRange(900, 1000)
        self.assertEqual(result, 174)
    
    def testDisplay(self):
        t = ThreePlusOne()
        t.displayResult(1, 10)
        t.displayResult(100, 200)
        t.displayResult(201, 210)
        t.displayResult(900, 1000)
    
if __name__ == '__main__':
    unittest.main()

require 'test/unit'

class ThreePlusOne
    attr_reader :recent_results, :recent_number
    attr_writer :recent_results, :recent_number
    
    def getArray(number)
        self.calculate(number)
        return self.recent_results
    end
    
    def getLength(number)
        self.calculate(number)
        return  self.recent_results.length
    end
    
    def getMaxLengthWithRange(start_number, end_number)
        max_length = 0
        for i in start_number..end_number
            current_length = self.getLength(i)
            max_length = [max_length, current_length].max
        end
        return max_length
    end
    
    def calculate(number)
        @recent_number = number
        @recent_results = []
        current_value = number
        @recent_results.push(current_value)
        while current_value != 1
            if current_value % 2 == 0 : current_value = current_value / 2
            else current_value = current_value * 3 + 1
            end
            @recent_results.push(current_value)
        end
        return @recent_results
    end        
end

class TestThreePlusOne < Test::Unit::TestCase
    def test_case
        t = ThreePlusOne.new()
        assert_equal(t.getArray(22), [22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1])
        assert_equal(t.getLength(22), 16)
        assert_equal(t.getMaxLengthWithRange(1, 10), 20)
        assert_equal(t.getMaxLengthWithRange(100, 200), 125)
        assert_equal(t.getMaxLengthWithRange(201, 210), 89)
        assert_equal(t.getMaxLengthWithRange(900, 1000), 174)
    end
end

최소 지식 원칙에서의 가이드라인

1. 객체 자체만의 호출

2. 메소드에서 매개 변수로 전달된 객체

3. 그 메소드에서 생성하거나 인스턴스를 만든 객체

4. 그 객체에 속하는 구성 요소

public static double GetTemplrature()

{

  // NOTE : 틀린 경우

  Thermoeter thermometer = station.GetThermometer();

  return thermometer.GetTemperature();

}

public static double GetTemperature()

{

  //NOTE : 맞는 경우 

  return station.GetTemperature();

 }